Move young independent handles to the end of the global handle's list.

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 23 matching lines @@
 
 namespace v8 {
 namespace internal {
 
 
 ObjectGroup::~ObjectGroup() {
   if (info_ != NULL) info_->Dispose();
 }
 
 
-class GlobalHandles::Node : public Malloced {
- public:
+GlobalHandles::Node::~Node() {
+  if (state_ != DESTROYED) Destroy(Isolate::Current()->global_handles());
+#ifdef DEBUG
+  // Zap the values for eager trapping.
+  object_ = NULL;
+  next_ = NULL;
+  prev_ = NULL;
+  parameter_or_next_free_.next_free = NULL;
+#endif
+}
 
-  void Initialize(Object* object) {
-    // Set the initial value of the handle.
-    object_ = object;
-    class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
-    independent_ = false;
-    state_  = NORMAL;
-    parameter_or_next_free_.parameter = NULL;
-    callback_ = NULL;
+
+
+bool GlobalHandles::Node::PostGarbageCollectionProcessing(
+    Isolate* isolate, GlobalHandles* global_handles) {
+  if (state_ != Node::PENDING) return false;
+  LOG(isolate, HandleEvent("GlobalHandle::Processing", handle().location()));
+  WeakReferenceCallback func = callback();
+  if (func == NULL) {
+    Destroy(global_handles);
+    return false;
   }
+  void* par = parameter();
+  state_ = NEAR_DEATH;
+  set_parameter(NULL);
 
-  Node() {
-    state_ = DESTROYED;
+  v8::Persistent<v8::Object> object = ToApi<v8::Object>(handle());
+  {
+    // Forbid reuse of destroyed nodes as they might be already deallocated.
+    // It's fine though to reuse nodes that were destroyed in weak callback
+    // as those cannot be deallocated until we are back from the callback.
+    global_handles->set_first_free(NULL);
+    if (global_handles->first_deallocated()) {
+      global_handles->first_deallocated()->set_next(global_handles->head());
+    }
+    // Check that we are not passing a finalized external string to
+    // the callback.
+    ASSERT(!object_->IsExternalAsciiString() ||
+           ExternalAsciiString::cast(object_)->resource() != NULL);
+    ASSERT(!object_->IsExternalTwoByteString() ||
+           ExternalTwoByteString::cast(object_)->resource() != NULL);
+    // Leaving V8.
+    VMState state(isolate, EXTERNAL);
+    func(object, par);
   }
+  // Absense of explicit cleanup or revival of weak handle
+  // in most of the cases would lead to memory leak.
+  ASSERT(state_ != NEAR_DEATH);
+  return true;
+}
 
-  explicit Node(Object* object) {
-    Initialize(object);
-    // Initialize link structure.
-    next_ = NULL;
+
+void GlobalHandles::Node::MakeWeak(GlobalHandles* global_handles,
+                                   void* parameter,
+                                   WeakReferenceCallback callback) {
+  LOG(global_handles->isolate(),
+      HandleEvent("GlobalHandle::MakeWeak", handle().location()));
+  ASSERT(state_ != DESTROYED);
+  if (state_ != WEAK && !IsNearDeath()) {
+    global_handles->number_of_weak_handles_++;
+    if (object_->IsJSGlobalObject()) {
+      global_handles->number_of_global_object_weak_handles_++;
+    }
   }
+  state_ = WEAK;
+  set_parameter(parameter);
+  callback_ = callback;
+}
 
-  ~Node() {
-    if (state_ != DESTROYED) Destroy(Isolate::Current()->global_handles());
-#ifdef DEBUG
-    // Zap the values for eager trapping.
-    object_ = NULL;
-    next_ = NULL;
-    parameter_or_next_free_.next_free = NULL;
-#endif
+
+void GlobalHandles::Node::ClearWeakness(GlobalHandles* global_handles) {

[antonm, 2011/05/23 19:44:19]

do we want to persist independence related state across MakeWeak/ClearWeakness
calls, maybe they should reset independence flags?

And shouldn't clearweakness move the handler out of the suffix as it's not
collectible anymore?

[Vyacheslav Egorov (Chromium), 2011/05/23 20:08:15]

I think independence is more a property of an object not a property of a handle
so I don't think ClearWeak should clean it. 

It's just an unfortunate design tradeoff that independence became property of a
handle.
 
The invariant of the tail is: if object is young and independent it's in the
tail. But converse of the invariant does not have to hold. I will update the
comments to make it more clear.

[antonm, 2011/05/24 10:58:38]

I am more concerned with is_in_independent_tail_

On 2011/05/23 20:08:15, Vyacheslav Egorov wrote:
I thought it need to be weak as well.  I am probably misinterpreting your CL,
but I thought the whole idea was to traverse the smaller set.  And all you need
is to traverse weak independent handles.  Hence all my questions :)

+  LOG(global_handles->isolate(),
+      HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
+  ASSERT(state_ != DESTROYED);
+  if (state_ == WEAK || IsNearDeath()) {
+    global_handles->number_of_weak_handles_--;
+    if (object_->IsJSGlobalObject()) {
+      global_handles->number_of_global_object_weak_handles_--;
+    }
   }
+  state_ = NORMAL;
+  set_parameter(NULL);
+}
 
-  void Destroy(GlobalHandles* global_handles) {
-    if (state_ == WEAK || IsNearDeath()) {
-      global_handles->number_of_weak_handles_--;
-      if (object_->IsJSGlobalObject()) {
-        global_handles->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(GlobalHandles* global_handles, void* parameter,
-                WeakReferenceCallback callback) {
-    LOG(global_handles->isolate(),
-        HandleEvent("GlobalHandle::MakeWeak", handle().location()));
-    ASSERT(state_ != DESTROYED);
-    if (state_ != WEAK && !IsNearDeath()) {
-      global_handles->number_of_weak_handles_++;
-      if (object_->IsJSGlobalObject()) {
-        global_handles->number_of_global_object_weak_handles_++;
-      }
-    }
-    state_ = WEAK;
-    set_parameter(parameter);
-    callback_ = callback;
-  }
-
-  void ClearWeakness(GlobalHandles* global_handles) {
-    LOG(global_handles->isolate(),
-        HandleEvent("GlobalHandle::ClearWeakness", handle().location()));
-    ASSERT(state_ != DESTROYED);
-    if (state_ == WEAK || IsNearDeath()) {
-      global_handles->number_of_weak_handles_--;
-      if (object_->IsJSGlobalObject()) {
-        global_handles->number_of_global_object_weak_handles_--;
-      }
-    }
-    state_ = NORMAL;
-    set_parameter(NULL);
-  }
-
-  void MarkIndependent(GlobalHandles* global_handles) {
-    LOG(global_handles->isolate(),
-        HandleEvent("GlobalHandle::MarkIndependent", handle().location()));
-    ASSERT(state_ != DESTROYED);
-    independent_ = true;
-  }
-
-  bool IsNearDeath() {
-    // Check for PENDING to ensure correct answer when processing callbacks.
-    return state_ == PENDING || state_ == NEAR_DEATH;
-  }
-
-  bool IsWeak() {
-    return state_ == WEAK;
-  }
-
-  bool CanBeRetainer() {
-    return state_ != DESTROYED && state_ != NEAR_DEATH;
-  }
-
-  void SetWrapperClassId(uint16_t class_id) {
-    class_id_ = class_id;
-  }
-
-  // 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;
-  }
-
-  // Returns the callback for this weak handle.
-  WeakReferenceCallback callback() { return callback_; }
-
-  bool PostGarbageCollectionProcessing(Isolate* isolate,
-                                       GlobalHandles* global_handles) {
-    if (state_ != Node::PENDING) return false;
-    LOG(isolate, HandleEvent("GlobalHandle::Processing", handle().location()));
-    WeakReferenceCallback func = callback();
-    if (func == NULL) {
-      Destroy(global_handles);
-      return false;
-    }
-    void* par = parameter();
-    state_ = NEAR_DEATH;
-    set_parameter(NULL);
-
-    v8::Persistent<v8::Object> object = ToApi<v8::Object>(handle());
-    {
-      // Forbid reuse of destroyed nodes as they might be already deallocated.
-      // It's fine though to reuse nodes that were destroyed in weak callback
-      // as those cannot be deallocated until we are back from the callback.
-      global_handles->set_first_free(NULL);
-      if (global_handles->first_deallocated()) {
-        global_handles->first_deallocated()->set_next(global_handles->head());
-      }
-      // Check that we are not passing a finalized external string to
-      // the callback.
-      ASSERT(!object_->IsExternalAsciiString() ||
-             ExternalAsciiString::cast(object_)->resource() != NULL);
-      ASSERT(!object_->IsExternalTwoByteString() ||
-             ExternalTwoByteString::cast(object_)->resource() != NULL);
-      // Leaving V8.
-      VMState state(isolate, EXTERNAL);
-      func(object, par);
-    }
-    // Absense of explicit cleanup or revival of weak handle
-    // in most of the cases would lead to memory leak.
-    ASSERT(state_ != NEAR_DEATH);
-    return true;
-  }
-
-  // Place the handle address first to avoid offset computation.
-  Object* object_;  // Storage for object pointer.
-
-  uint16_t class_id_;
-
-  // 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_ : 4;  // Need one more bit for MSVC as it treats enums as signed.
-
-  bool independent_ : 1;
-
- 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_;
-
-  // Linkage for the list.
-  Node* next_;
-
- public:
-  TRACK_MEMORY("GlobalHandles::Node")
-};
+void GlobalHandles::Node::MarkIndependent(GlobalHandles* global_handles) {
+  LOG(global_handles->isolate(),
+      HandleEvent("GlobalHandle::MarkIndependent", handle().location()));
+  ASSERT(state_ != DESTROYED);
+  independent_ = true;
+}
 
 
 class GlobalHandles::Pool {
   public:
     Pool() {
       current_ = new Chunk();
       current_->previous = NULL;
       next_ = current_->nodes;
       limit_ = current_->nodes + kNodesPerChunk;
     }
@@ skipping 44 matching lines @@
     Chunk* current_;
     Node* next_;
     Node* limit_;
 };
 
 
 GlobalHandles::GlobalHandles(Isolate* isolate)
     : isolate_(isolate),
       number_of_weak_handles_(0),
       number_of_global_object_weak_handles_(0),
-      head_(NULL),
+      young_independent_anchor_(&anchor_node_),
       first_free_(NULL),
       first_deallocated_(NULL),
       pool_(new Pool()),
       post_gc_processing_count_(0),
       object_groups_(4) {
 }
 
 
 GlobalHandles::~GlobalHandles() {
   delete pool_;
   pool_ = 0;
 }
 
 
 Handle<Object> GlobalHandles::Create(Object* value) {
   isolate_->counters()->global_handles()->Increment();
   Node* result;
   if (first_free()) {
     // Take the first node in the free list.
     result = first_free();
     set_first_free(result->next_free());
   } else if (first_deallocated()) {

[antonm, 2011/05/23 19:44:19]

just FYI:  I recently thought about it, and chances really are we don't need
both free and deallocated since we allocate the stuff from the pool anyway.  I
should have probably cleaned it up before.  In any event it may compensate for
newly added complexity.

[Vyacheslav Egorov (Chromium), 2011/05/23 20:08:15]

Well if we can remove "free" stuff than I don't need a double linked list --- a
single linked list will suffice. 

If there is not "reuse" in the middle of the list then the following assumption
will hold --- a handle is mark as independent soon after creation so we can find
it's "prev" by linear search. 

What do you think, Vitaly?

[antonm, 2011/05/24 10:58:38]

Not free, but deallocated.

On 2011/05/23 20:08:15, Vyacheslav Egorov wrote:

     // Next try deallocated list
     result = first_deallocated();
     set_first_deallocated(result->next_free());
     ASSERT(result->next() == head());
+    if (head() != NULL) head()->set_prev(result);

[antonm, 2011/05/23 19:44:19]

nit: mixed style: it's (first_free()) in old code vs. if (head() != NULL),
probably should be unified

+    result->set_prev(NULL);
     set_head(result);
   } else {
     // Allocate a new node.
     result = pool_->Allocate();
+    if (head() != NULL) head()->set_prev(result);
     result->set_next(head());
+    result->set_prev(NULL);
     set_head(result);
   }
   result->Initialize(value);
   return result->handle();
 }
 
 
 void GlobalHandles::Destroy(Object** location) {
   isolate_->counters()->global_handles()->Decrement();
   if (location == NULL) return;
@@ skipping 11 matching lines @@
   Node::FromLocation(location)->MakeWeak(this, parameter, callback);
 }
 
 
 void GlobalHandles::ClearWeakness(Object** location) {
   Node::FromLocation(location)->ClearWeakness(this);
 }
 
 
 void GlobalHandles::MarkIndependent(Object** location) {
-  Node::FromLocation(location)->MarkIndependent(this);
+  Node* node = Node::FromLocation(location);
+
+  if (node->independent_) return;
+
+  node->MarkIndependent(this);
+
+  if (node->is_in_independent_tail_) {

[antonm, 2011/05/23 19:44:19]

is it possible for this to be true?  if node wasn't independent, it should not
have belonged to independent tail unless there is a bug, no?

[Vyacheslav Egorov (Chromium), 2011/05/23 20:08:15]

Yes it is. If the handle is destroyed and reused without GC in between.

Also see the comment about invariant of the tail above.

+    return;
+  }
+
+  if (isolate_->heap()->InNewSpace(node->object_)) {
+    if (node == young_independent_anchor_) {
+      ASSERT(node->prev() != NULL);
+      young_independent_anchor_ = node->prev();
+    } else {
+      UnlinkNode(node);
+      LinkAfter(young_independent_anchor_, node);
+    }
+    node->is_in_independent_tail_ = true;
+    ASSERT(FirstYoungIndependent() == node);
+  }
 }
 
 
 bool GlobalHandles::IsNearDeath(Object** location) {
   return Node::FromLocation(location)->IsNearDeath();
 }
 
 
 bool GlobalHandles::IsWeak(Object** location) {
   return Node::FromLocation(location)->IsWeak();
 }
 
 
 void GlobalHandles::SetWrapperClassId(Object** location, uint16_t class_id) {
   Node::FromLocation(location)->SetWrapperClassId(class_id);
 }
 
 
 void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
   // Traversal of GC roots in the global handle list that are marked as
   // WEAK, PENDING or NEAR_DEATH.
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     if (current->state_ == Node::WEAK
       || current->state_ == Node::PENDING
       || current->state_ == Node::NEAR_DEATH) {
-      v->VisitPointer(&current->object_);
-    }
-  }
-}
-
-
-void GlobalHandles::IterateWeakIndependentRoots(ObjectVisitor* v) {
-  // Traversal of GC roots in the global handle list that are independent
-  // and marked as WEAK, PENDING or NEAR_DEATH.
-  for (Node* current = head_; current != NULL; current = current->next()) {
-    if (!current->independent_) continue;
-    if (current->state_ == Node::WEAK
-      || current->state_ == Node::PENDING
-      || current->state_ == Node::NEAR_DEATH) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
 void GlobalHandles::IterateWeakRoots(WeakReferenceGuest f,
                                      WeakReferenceCallback callback) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     if (current->IsWeak() && current->callback() == callback) {
       f(current->object_, current->parameter());
     }
   }
 }
 
 
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     if (current->state_ == Node::WEAK) {
       if (f(&current->object_)) {
         current->state_ = Node::PENDING;
         LOG(isolate_,
             HandleEvent("GlobalHandle::Pending", current->handle().location()));
       }
     }
   }
 }
 
 
+void GlobalHandles::IterateWeakIndependentRoots(ObjectVisitor* v) {
+  // Traversal of GC roots in the global handle list that are independent
+  // and marked as WEAK, PENDING or NEAR_DEATH.
+  for (Node* current = FirstYoungIndependent();
+       current != NULL;
+       current = current->next()) {
+    if (!current->independent_) continue;

[antonm, 2011/05/23 19:44:19]

shouldn't it always hold: ASSERT(current->independent_)?  At least the name
suggests that :)

[Vyacheslav Egorov (Chromium), 2011/05/23 20:08:15]

It was an assertion initially but... see above :-)

+    if (current->state_ == Node::WEAK
+      || current->state_ == Node::PENDING
+      || current->state_ == Node::NEAR_DEATH) {
+      v->VisitPointer(&current->object_);
+    }
+  }
+}
+
+
 void GlobalHandles::IdentifyWeakIndependentHandles(WeakSlotCallbackWithHeap f) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
-    if (current->state_ == Node::WEAK && current->independent_) {
+  for (Node* current = FirstYoungIndependent();
+       current != NULL;
+       current = current->next()) {
+    if (!current->independent_) continue;

[antonm, 2011/05/23 19:44:19]

ditto

[Vyacheslav Egorov (Chromium), 2011/05/23 20:08:15]

ditto :-)

+    if (current->state_ == Node::WEAK) {
       if (f(isolate_->heap(), &current->object_)) {
         current->state_ = Node::PENDING;
         LOG(isolate_,
             HandleEvent("GlobalHandle::Pending", current->handle().location()));
       }
     }
   }
 }
 
 
+void GlobalHandles::IterateStrongAndDependentRoots(ObjectVisitor* v) {
+  Node* first_young_independent = FirstYoungIndependent();
+  for (Node* current = head();
+       current != first_young_independent;
+       current = current->next()) {
+    if (current->state_ != Node::DESTROYED) {
+      v->VisitPointer(&current->object_);
+    }
+  }
+
+  for (Node* current = first_young_independent;
+       current != NULL;
+       current = current->next()) {
+    if ((current->independent_ && current->state_ == Node::NORMAL) ||
+        (!current->independent_ && current->state_ != Node::DESTROYED)) {
+      v->VisitPointer(&current->object_);
+    }
+  }
+}
+
+
+void GlobalHandles::RemoveFromIndependentTail(Node* node) {
+  if (FirstYoungIndependent() != node) {
+    UnlinkNode(node);
+    LinkAfter(young_independent_anchor_, node);
+  }
+  young_independent_anchor_ = node;
+  node->is_in_independent_tail_ = false;
+}
+
+
+void GlobalHandles::UnlinkNode(Node* node) {
+  Node* next = node->next();
+  Node* prev = node->prev();
+
+  if (next != NULL) next->set_prev(prev);
+
+  prev->set_next(next);
+
+  if (prev == &anchor_node_) {
+    if (first_deallocated()) first_deallocated()->set_next(next);
+  }
+
+  if (young_independent_anchor_ == node) {
+    young_independent_anchor_ = prev;
+  }
+
+  node->is_in_independent_tail_ = false;

[antonm, 2011/05/23 19:44:19]

is it mandatory here?  apparently you overwrite it later anyway.

[Vyacheslav Egorov (Chromium), 2011/05/23 20:08:15]

there is one callsite that calls UnlinkNode directly (see line 475).

[antonm, 2011/05/24 10:58:38]

Maybe it should go to this callsite then, but it's a nit.

On 2011/05/23 20:08:15, Vyacheslav Egorov wrote:

+}
+
+
+void GlobalHandles::LinkAfter(Node* prev, Node* node) {
+  ASSERT(prev != NULL);
+  Node* next = prev->next();
+  prev->set_next(node);
+  node->set_prev(prev);
+
+  node->set_next(next);
+  if (next != NULL) next->set_prev(node);
+
+  if (prev == &anchor_node_) {
+    if (first_deallocated()) first_deallocated()->set_next(node);
+  }
+}
+
+
 bool GlobalHandles::PostGarbageCollectionProcessing(
     GarbageCollector collector) {
   // Process weak global handle callbacks. This must be done after the
   // GC is completely done, because the callbacks may invoke arbitrary
   // API functions.
   // At the same time deallocate all DESTROYED nodes.
   ASSERT(isolate_->heap()->gc_state() == Heap::NOT_IN_GC);
   const int initial_post_gc_processing_count = ++post_gc_processing_count_;
   bool next_gc_likely_to_collect_more = false;
-  Node** p = &head_;
-  while (*p != NULL) {
+
+  Node* next_node = NULL;
+  for (Node* node = (collector == SCAVENGER) ? FirstYoungIndependent() : head();
+       node != NULL;
+       node = next_node) {
+    next_node = node->next();
+    ASSERT(collector == MARK_COMPACTOR || node->is_in_independent_tail_);
+
     // Skip dependent handles. Their weak callbacks might expect to be
     // called between two global garbage collection callbacks which
     // are not called for minor collections.
-    if (collector == SCAVENGER && !(*p)->independent_) {
-      p = (*p)->next_addr();
+    if (collector == SCAVENGER && !node->independent_) {
+      RemoveFromIndependentTail(node);
       continue;
     }
 
-    if ((*p)->PostGarbageCollectionProcessing(isolate_, this)) {
+    if (node->PostGarbageCollectionProcessing(isolate_, this)) {
       if (initial_post_gc_processing_count != post_gc_processing_count_) {
         // Weak callback triggered another GC and another round of
         // PostGarbageCollection processing.  The current node might
         // have been deleted in that round, so we need to bail out (or
         // restart the processing).
         break;
       }
     }
-    if ((*p)->state_ == Node::DESTROYED) {
-      // Delete the link.
-      Node* node = *p;
-      *p = node->next();  // Update the link.
-      if (first_deallocated()) {
-        first_deallocated()->set_next(node);
-      }
+
+    if (node->state_ == Node::DESTROYED) {
+      UnlinkNode(node);
+
+      if (first_deallocated()) first_deallocated()->set_next(node);
       node->set_next_free(first_deallocated());
       set_first_deallocated(node);
       next_gc_likely_to_collect_more = true;
-    } else {
-      p = (*p)->next_addr();
+    } else if (node->is_in_independent_tail_ &&
+               !isolate_->heap()->InNewSpace(node->object_)) {
+      RemoveFromIndependentTail(node);
     }
   }
   set_first_free(NULL);
   if (first_deallocated()) {
     first_deallocated()->set_next(head());
   }
 
   return next_gc_likely_to_collect_more;
 }
 
 
 void GlobalHandles::IterateStrongRoots(ObjectVisitor* v) {
   // Traversal of global handles marked as NORMAL.
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     if (current->state_ == Node::NORMAL) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
 void GlobalHandles::IterateAllRoots(ObjectVisitor* v) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     if (current->state_ != Node::DESTROYED) {
       v->VisitPointer(&current->object_);
     }
   }
 }
 
 
-void GlobalHandles::IterateStrongAndDependentRoots(ObjectVisitor* v) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
-    if ((current->independent_ && current->state_ == Node::NORMAL) ||
-        (!current->independent_ && current->state_ != Node::DESTROYED)) {
-      v->VisitPointer(&current->object_);
-    }
-  }
-}
-
-
 void GlobalHandles::IterateAllRootsWithClassIds(ObjectVisitor* v) {
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     if (current->class_id_ != v8::HeapProfiler::kPersistentHandleNoClassId &&
         current->CanBeRetainer()) {
       v->VisitEmbedderReference(&current->object_, current->class_id_);
     }
   }
 }
 
 
 void GlobalHandles::TearDown() {
   // Reset all the lists.
   set_head(NULL);
   set_first_free(NULL);
   set_first_deallocated(NULL);
   pool_->Release();
 }
 
 
 void GlobalHandles::RecordStats(HeapStats* stats) {
   *stats->global_handle_count = 0;
   *stats->weak_global_handle_count = 0;
   *stats->pending_global_handle_count = 0;
   *stats->near_death_global_handle_count = 0;
   *stats->destroyed_global_handle_count = 0;
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     *stats->global_handle_count += 1;
     if (current->state_ == Node::WEAK) {
       *stats->weak_global_handle_count += 1;
     } else if (current->state_ == Node::PENDING) {
       *stats->pending_global_handle_count += 1;
     } else if (current->state_ == Node::NEAR_DEATH) {
       *stats->near_death_global_handle_count += 1;
     } else if (current->state_ == Node::DESTROYED) {
       *stats->destroyed_global_handle_count += 1;
     }
   }
 }
 
 #ifdef DEBUG
 
 void GlobalHandles::PrintStats() {
   int total = 0;
   int weak = 0;
   int pending = 0;
   int near_death = 0;
   int destroyed = 0;
 
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     total++;
     if (current->state_ == Node::WEAK) weak++;
     if (current->state_ == Node::PENDING) pending++;
     if (current->state_ == Node::NEAR_DEATH) near_death++;
     if (current->state_ == Node::DESTROYED) destroyed++;
   }
 
   PrintF("Global Handle Statistics:\n");
   PrintF("  allocated memory = %" V8_PTR_PREFIX "dB\n", sizeof(Node) * total);
   PrintF("  # weak       = %d\n", weak);
   PrintF("  # pending    = %d\n", pending);
   PrintF("  # near_death = %d\n", near_death);
   PrintF("  # destroyed  = %d\n", destroyed);
   PrintF("  # total      = %d\n", total);
 }
 
 void GlobalHandles::Print() {
   PrintF("Global handles:\n");
-  for (Node* current = head_; current != NULL; current = current->next()) {
+  for (Node* current = head(); current != NULL; current = current->next()) {
     PrintF("  handle %p to %p (weak=%d)\n",
            reinterpret_cast<void*>(current->handle().location()),
            reinterpret_cast<void*>(*current->handle()),
            current->state_ == Node::WEAK);
   }
 }
 
 #endif
 
 
@@ skipping 38 matching lines @@
 
 void GlobalHandles::RemoveImplicitRefGroups() {
   for (int i = 0; i < implicit_ref_groups_.length(); i++) {
     implicit_ref_groups_.at(i)->Dispose();
   }
   implicit_ref_groups_.Clear();
 }
 
 
 } }  // namespace v8::internal