Implemented really weak handles.

src/global-handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 21 matching lines @@
 
 namespace v8 {
 namespace internal {
 
 class GlobalHandles::Node : public Malloced {
  public:
 
   void Initialize(Object* object) {
     // Set the initial value of the handle.
     object_ = object;
+    really_weak_ = false;
     state_  = NORMAL;
     parameter_or_next_free_.parameter = NULL;
     callback_ = NULL;
   }
 
   explicit Node(Object* object) {
     Initialize(object);
     // Initialize link structure.
     next_ = NULL;
   }
 
   ~Node() {
     if (state_ != DESTROYED) Destroy();
 #ifdef DEBUG
     // Zap the values for eager trapping.
     object_ = NULL;
     next_ = NULL;
     parameter_or_next_free_.next_free = NULL;
 #endif
   }
 
   void Destroy() {
     if (state_ == WEAK || IsNearDeath()) {
       GlobalHandles::number_of_weak_handles_--;
-      if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_--;
-      }
     }
     state_ = DESTROYED;
   }
 
   // Accessors for next_.
   Node* next() { return next_; }
   void set_next(Node* value) { next_ = value; }
   Node** next_addr() { return &next_; }
 
   // Accessors for next free node in the free list.
   Node* next_free() {
     ASSERT(state_ == DESTROYED);
     return parameter_or_next_free_.next_free;
   }
   void set_next_free(Node* value) {
     ASSERT(state_ == DESTROYED);
     parameter_or_next_free_.next_free = value;
   }
 
   // Returns a link from the handle.
   static Node* FromLocation(Object** location) {
     ASSERT(OFFSET_OF(Node, object_) == 0);
     return reinterpret_cast<Node*>(location);
   }
 
   // Returns the handle.
   Handle<Object> handle() { return Handle<Object>(&object_); }
 
   // Make this handle weak.
-  void MakeWeak(void* parameter, WeakReferenceCallback callback) {
+  void MakeWeak(void* parameter, WeakReferenceCallback callback,

[Christian Plesner Hansen, 2009/10/06 13:47:21]

The 'callback' parameter should be moved to the next line as well.

+                bool really_weak) {
     LOG(HandleEvent("GlobalHandle::MakeWeak", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ != WEAK && !IsNearDeath()) {
       GlobalHandles::number_of_weak_handles_++;
-      if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_++;
-      }
     }
+    really_weak_ = really_weak;
     state_ = WEAK;
     set_parameter(parameter);
     callback_ = callback;
   }
 
   void ClearWeakness() {
     LOG(HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
     ASSERT(state_ != DESTROYED);
     if (state_ == WEAK || IsNearDeath()) {
+      // Can't clear weakness of near death really weak handle because
+      // the object may have been collected already.
+      ASSERT(!IsNearDeath() || !really_weak_);

[Christian Plesner Hansen, 2009/10/06 13:47:21]

Are we sure this can't happen?  Wouldn't it be safer to just ignore it in that
case, rather than ASSERT?

       GlobalHandles::number_of_weak_handles_--;
-      if (object_->IsJSGlobalObject()) {
-        GlobalHandles::number_of_global_object_weak_handles_--;
-      }
     }
+    really_weak_ = false;
     state_ = NORMAL;
     set_parameter(NULL);
   }
 
   bool IsNearDeath() {
     // Check for PENDING to ensure correct answer when processing callbacks.
     return state_ == PENDING || state_ == NEAR_DEATH;
   }
 
   bool IsWeak() {
     return state_ == WEAK;
   }
 
+  bool IsReallyWeak() {
+    return really_weak_;
+  }
+
   // Returns the id for this weak handle.
   void set_parameter(void* parameter) {
     ASSERT(state_ != DESTROYED);
     parameter_or_next_free_.parameter = parameter;
   }
   void* parameter() {
     ASSERT(state_ != DESTROYED);
     return parameter_or_next_free_.parameter;
   }
 
@@ skipping 20 matching lines @@
       // Leaving V8.
       VMState state(EXTERNAL);
       func(object, par);
     }
     return true;
   }
 
   // Place the handle address first to avoid offset computation.
   Object* object_;  // Storage for object pointer.
 
+  bool really_weak_ : 1;
+
   // Transition diagram:
   // NORMAL <-> WEAK -> PENDING -> NEAR_DEATH -> { NORMAL, WEAK, DESTROYED }
   enum State {
     NORMAL,      // Normal global handle.
     WEAK,        // Flagged as weak but not yet finalized.
     PENDING,     // Has been recognized as only reachable by weak handles.
     NEAR_DEATH,  // Callback has informed the handle is near death.
     DESTROYED
   };
-  State state_;
+  State state_ : 3;
 
  private:
   // Handle specific callback.
   WeakReferenceCallback callback_;
   // Provided data for callback.  In DESTROYED state, this is used for
   // the free list link.
   union {
     void* parameter;
     Node* next_free;
   } parameter_or_next_free_;
@@ skipping 31 matching lines @@
   node->Destroy();
   // Link the destroyed.
   node->set_next_free(first_free());
   set_first_free(node);
 }
 
 
 void GlobalHandles::MakeWeak(Object** location, void* parameter,
                              WeakReferenceCallback callback) {
   ASSERT(callback != NULL);
-  Node::FromLocation(location)->MakeWeak(parameter, callback);
+  Node::FromLocation(location)->MakeWeak(parameter, callback, false);
 }
 
 
+void GlobalHandles::MakeReallyWeak(Object** location, void* parameter,
+                                   WeakReferenceCallback callback) {
+  ASSERT(callback != NULL);
+  Node::FromLocation(location)->MakeWeak(parameter, callback, true);
+}
+
+
 void GlobalHandles::ClearWeakness(Object** location) {
   Node::FromLocation(location)->ClearWeakness();
 }
 
 
 bool GlobalHandles::IsNearDeath(Object** location) {
   return Node::FromLocation(location)->IsNearDeath();
 }
 
 
 bool GlobalHandles::IsWeak(Object** location) {
   return Node::FromLocation(location)->IsWeak();
 }
 
 
+bool GlobalHandles::IsReallyWeak(Object** location) {
+  return Node::FromLocation(location)->IsReallyWeak();
+}
+
+
 void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
   // Traversal of GC roots in the global handle list that are marked as
   // WEAK or PENDING.
   for (Node* current = head_; current != NULL; current = current->next()) {
-    if (current->state_ == Node::WEAK
-      || current->state_ == Node::PENDING
-      || current->state_ == Node::NEAR_DEATH) {
+    if (current->state_ == Node::WEAK ||
+        (!current->really_weak_ &&
+         (current->state_ == Node::PENDING ||
+          current->state_ == Node::NEAR_DEATH))) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
   for (Node* current = head_; current != NULL; current = current->next()) {
     if (current->state_ == Node::WEAK) {
       if (f(&current->object_)) {
@@ skipping 32 matching lines @@
       delete node;
     } else {
       p = (*p)->next_addr();
     }
   }
   set_first_free(NULL);
 }
 
 
 void GlobalHandles::IterateRoots(ObjectVisitor* v) {
-  // Traversal of global handles marked as NORMAL or NEAR_DEATH.
+  // Traversal of global handles marked as NORMAL.
   for (Node* current = head_; current != NULL; current = current->next()) {
     if (current->state_ == Node::NORMAL) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 void GlobalHandles::TearDown() {
   // Delete all the nodes in the linked list.
   Node* current = head_;
   while (current != NULL) {
     Node* n = current;
     current = current->next();
     delete n;
   }
   // Reset the head and free_list.
   set_head(NULL);
   set_first_free(NULL);
 }
 
 
 int GlobalHandles::number_of_weak_handles_ = 0;
-int GlobalHandles::number_of_global_object_weak_handles_ = 0;
 
 GlobalHandles::Node* GlobalHandles::head_ = NULL;
 GlobalHandles::Node* GlobalHandles::first_free_ = NULL;
 
 #ifdef DEBUG
 
 void GlobalHandles::PrintStats() {
   int total = 0;
   int weak = 0;
   int pending = 0;
@@ skipping 26 matching lines @@
 }
 
 #endif
 
 List<ObjectGroup*>* GlobalHandles::ObjectGroups() {
   // Lazily initialize the list to avoid startup time static constructors.
   static List<ObjectGroup*> groups(4);
   return &groups;
 }
 
+
 void GlobalHandles::AddGroup(Object*** handles, size_t length) {
   ObjectGroup* new_entry = new ObjectGroup(length);
   for (size_t i = 0; i < length; ++i)
     new_entry->objects_.Add(handles[i]);
   ObjectGroups()->Add(new_entry);
 }
 
 
 void GlobalHandles::RemoveObjectGroups() {
   List<ObjectGroup*>* object_groups = ObjectGroups();
-  for (int i = 0; i< object_groups->length(); i++) {
+  for (int i = 0; i < object_groups->length(); ++i) {

[Christian Plesner Hansen, 2009/10/06 13:47:21]

Changing from i++ to ++i shouldn't make any difference -- I'd prefer to keep the
i++ for consistency.

     delete object_groups->at(i);
   }
   object_groups->Clear();
 }
 
 
 } }  // namespace v8::internal