Provide API support for weak handles and post-mortem finalization.

runtime/vm/gc_marker.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/gc_marker.h"
 
 #include "vm/allocation.h"
+#include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // A simple chunked marking stack.
 class MarkingStack : public ValueObject {
@@ skipping 162 matching lines @@
 
   Heap* heap_;
   Heap* vm_heap_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitor);
 };
 
 
-class MarkingWeakVisitor : public ObjectPointerVisitor {
+class MarkingWeakVisitor : public HandleVisitor {
  public:
   MarkingWeakVisitor() {
   }
 
-  void VisitPointers(RawObject** first, RawObject** last) {
-    for (RawObject** current = first; current <= last; current++) {
-      RawObject* raw_obj = *current;
-      ASSERT(raw_obj->IsHeapObject());
-      if (!raw_obj->IsMarked() && raw_obj->IsOldObject()) {
-        *current = Object::null();
-      }
+  void VisitHandle(uword* addr) {
+    WeakPersistentHandle* handle =
+        reinterpret_cast<WeakPersistentHandle*>(addr);
+    RawObject* raw_obj = handle->raw();
+    ASSERT(raw_obj->IsHeapObject());
+    if (!raw_obj->IsMarked() && raw_obj->IsOldObject()) {
+      handle->Finalize();

[Anton Muhin, 2012/01/12 13:40:26]

there might be unpleasant problem: naively implemented finalizer may reenter
into Dart and therefore into GC.  Chances are high you would like to prohibit
such behaviour, but that has some implications:

1) documentation should be updated;
2) you should probably provide some callbacks to clean up objects pending
destruction---if all finalizer can do is to move an object into some
to-be-deleted queue, embedder needs a trigger for it, ideally {s,}he should be
able to do that at the first safe point;
3) it might be worth adding a checks, at least in DEBUG mode, that verifies that
finalizer doesn't reenter into GC from finalizer.

Or you may allow finalizers to reenter into Dart (as v8 does).

[cshapiro, 2012/01/12 18:15:38]

Correct.  There is one case we consider to be safe and that is calling back into
the VM to delete a handle.  Aside from that, it is my intention to establish a
"no callback" scope in or around the invocation of Finalize() that will prohibit
all other callbacks into the VM.  At the very least this will be a debug mode
check as you suggested in #3.

Regarding #2, unlike V8, which signals when an object is about to be reclaimed,
Dart signals when an object is already dead.  As such, we cannot provide the
callback with access to the object as it no longer exists.  The intention is for
the embedding application to provide enough state in the peer to make a cleanup
action possible. 

[Anton Muhin, 2012/01/13 14:20:58]

Carl, sorry, I wasn't clear enough regarding #2.

Imagine the common case: one wraps a pointer into Dart object and wants to
destroy the objects once Dart wrapper is unreachable.  With the current design
one cannot just invoke the dtor on the pointer as typically, esp. in the big
projects, one cannot foresee if dtor will reenter Dart or not.  That means that
one has to defer dtor invocation.  On the other hand, the sooner object is
destroyed and the memory is reclaimed, the better.  Therefore, one option might
be a callback which is invoked precisely after GC happened---the embedder will
destroy all the queued objects in this callback.  Does that make sense?

On 2012/01/12 18:15:38, cshapiro wrote:

[cshapiro, 2012/01/13 22:56:46]

Thanks for the clarification.

I discussed your concern with Ivan and the current opinion is that situations
where the finalizer is non-trivial should be resolved by queuing an object for
destruction through the event queue (I believe the render even queue was
mentioned) and having those actions be handled outside the garbage collector.

If you feel this does not work for you, let's have a discussion outside this
review to resolve whether or not we have something workable.

     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MarkingWeakVisitor);
 };
 
 
 void GCMarker::Prologue(Isolate* isolate) {
   // Nothing to do at the moment.
 }
 
 
 void GCMarker::IterateRoots(Isolate* isolate, ObjectPointerVisitor* visitor) {
-  isolate->VisitStrongObjectPointers(visitor,
-                                     StackFrameIterator::kDontValidateFrames);
+  isolate->VisitObjectPointers(visitor,
+                               StackFrameIterator::kDontValidateFrames);
   heap_->IterateNewPointers(visitor);
   heap_->IterateCodePointers(visitor);
 }
 
 
-void GCMarker::IterateWeakRoots(Isolate* isolate,
-                                ObjectPointerVisitor* visitor) {
-  isolate->VisitWeakObjectPointers(visitor);
+void GCMarker::IterateWeakRoots(Isolate* isolate, HandleVisitor* visitor) {
+  isolate->VisitWeakPersistentHandles(visitor);
 }
 
 
 void GCMarker::DrainMarkingStack(Isolate* isolate,
                                  MarkingVisitor* visitor) {
   while (!visitor->marking_stack()->IsEmpty()) {
     RawObject* raw_obj = visitor->marking_stack()->Pop();
     raw_obj->VisitPointers(visitor);
   }
 }
 
 
 void GCMarker::MarkObjects(Isolate* isolate, PageSpace* page_space) {
   MarkingStack marking_stack;
   Prologue(isolate);
   MarkingVisitor mark(heap_, page_space, &marking_stack);
   IterateRoots(isolate, &mark);
   DrainMarkingStack(isolate, &mark);
   MarkingWeakVisitor mark_weak;
   IterateWeakRoots(isolate, &mark_weak);
 }
 
 }  // namespace dart