[WIP] New GC related APIs.

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 19 matching lines @@
 #include "api.h"
 #include "global-handles.h"
 
 #include "vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 ObjectGroup::~ObjectGroup() {
-  if (info_ != NULL) info_->Dispose();
+  if (info != NULL) info->Dispose();
 }
 
 
+GroupRetainedObjectInfo::~GroupRetainedObjectInfo() {
+}
+
+
 class GlobalHandles::Node {
  public:
   // State transition diagram:
   // FREE -> NORMAL <-> WEAK -> PENDING -> NEAR_DEATH -> { NORMAL, WEAK, FREE }
   enum State {
     FREE = 0,
     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.
@@ skipping 377 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NodeIterator);
 };
 
 
 GlobalHandles::GlobalHandles(Isolate* isolate)
     : isolate_(isolate),
       number_of_global_handles_(0),
       first_block_(NULL),
       first_used_block_(NULL),
       first_free_(NULL),
-      post_gc_processing_count_(0) {}
+      post_gc_processing_count_(0),
+      object_groups_(new List<ObjectGroupConnection>()) {}
 
 
 GlobalHandles::~GlobalHandles() {
   NodeBlock* block = first_block_;
   while (block != NULL) {
     NodeBlock* tmp = block->next();
     delete block;
     block = tmp;
   }
   first_block_ = NULL;
+  delete object_groups_;
 }
 
 
 Handle<Object> GlobalHandles::Create(Object* value) {
   isolate_->counters()->global_handles()->Increment();
   number_of_global_handles_++;
   if (first_free_ == NULL) {
     first_block_ = new NodeBlock(first_block_);
     first_block_->PutNodesOnFreeList(&first_free_);
   }
@@ skipping 106 matching lines @@
   for (int i = 0; i < new_space_nodes_.length(); ++i) {
     Node* node = new_space_nodes_[i];
     ASSERT(node->is_in_new_space_list());
     if ((node->is_independent() || node->is_partially_dependent()) &&
         node->IsWeakRetainer()) {
       v->VisitPointer(node->location());
     }
   }
 }
 
-
 bool GlobalHandles::IterateObjectGroups(ObjectVisitor* v,
                                         WeakSlotCallbackWithHeap can_skip) {
-  int last = 0;
+  if (object_groups_->length() == 0)
+    return false;
+
+  object_groups_->Sort();
+  // Stores information about unvisited object groups for later use.
+  List<ObjectGroupConnection>* new_object_groups =
+      new List<ObjectGroupConnection>();
+
+  void* current_group_id = NULL;
+  size_t current_group_start = 0;
   bool any_group_was_visited = false;
-  for (int i = 0; i < object_groups_.length(); i++) {
-    ObjectGroup* entry = object_groups_.at(i);
-    ASSERT(entry != NULL);
 
-    Object*** objects = entry->objects_;
-    bool group_should_be_visited = false;
-    for (size_t j = 0; j < entry->length_; j++) {
-      Object* object = *objects[j];
-      if (object->IsHeapObject()) {
-        if (!can_skip(isolate_->heap(), &object)) {
-          group_should_be_visited = true;
-          break;
+  for (int i = 0; i <= object_groups_->length(); ++i) {
+    if (i == 0)
+      current_group_id = object_groups_->at(i).id;
+    if (i == object_groups_->length() ||
+        current_group_id != object_groups_->at(i).id) {
+      // Group detected: objects in indices [current_group_start, i[.
+      bool group_should_be_visited = false;
+      for (int j = current_group_start; j < i; ++j) {
+        Object* object = *(object_groups_->at(j).object);
+        if (object->IsHeapObject()) {
+          if (!can_skip(isolate_->heap(), &object)) {
+            group_should_be_visited = true;
+            break;
+          }
         }
       }
-    }
-
-    if (!group_should_be_visited) {
-      object_groups_[last++] = entry;
-      continue;
-    }
-
-    // An object in the group requires visiting, so iterate over all
-    // objects in the group.
-    for (size_t j = 0; j < entry->length_; ++j) {
-      Object* object = *objects[j];
-      if (object->IsHeapObject()) {
-        v->VisitPointer(&object);
-        any_group_was_visited = true;
+      if (!group_should_be_visited) {
+        for (int j = current_group_start; j < i; ++j)
+          new_object_groups->Add(object_groups_->at(j));

[Michael Starzinger, 2013/04/09 14:18:40]

It would be good if we could get by with an in-place version of this function as
before which doesn't require to copy into a new-list.

[marja, 2013/04/09 16:46:51]

Done.

+      } else {
+        // An object in the group requires visiting, so iterate over all
+        // objects in the group.
+        for (int j = current_group_start; j < i; ++j) {
+          Object* object = *(object_groups_->at(j).object);
+          if (object->IsHeapObject()) {
+            v->VisitPointer(&object);
+            any_group_was_visited = true;
+          }
+        }
+      }
+      if (i < object_groups_->length()) {
+        current_group_id = object_groups_->at(i).id;
+        current_group_start = i;
       }
     }
-
-    // Once the entire group has been iterated over, set the object
-    // group to NULL so it won't be processed again.
-    entry->Dispose();
-    object_groups_.at(i) = NULL;
   }
-  object_groups_.Rewind(last);
+  delete object_groups_;
+  object_groups_ = new_object_groups;
   return any_group_was_visited;
 }
 
 
 bool GlobalHandles::PostGarbageCollectionProcessing(
     GarbageCollector collector, GCTracer* tracer) {
   // Process weak global handle callbacks. This must be done after the
   // GC is completely done, because the callbacks may invoke arbitrary
   // API functions.
   ASSERT(isolate_->heap()->gc_state() == Heap::NOT_IN_GC);
@@ skipping 187 matching lines @@
                                    v8::RetainedObjectInfo* info) {
 #ifdef DEBUG
   for (size_t i = 0; i < length; ++i) {
     ASSERT(!Node::FromLocation(handles[i])->is_independent());
   }
 #endif
   if (length == 0) {
     if (info != NULL) info->Dispose();
     return;
   }
-  object_groups_.Add(ObjectGroup::New(handles, length, info));
+  for (size_t i = 0; i < length; ++i)
+    object_groups_->Add(ObjectGroupConnection(handles[0], handles[i]));
+  retained_object_infos_.Add(GroupRetainedObjectInfo(handles[0], info));
 }
 
 
+void GlobalHandles::SetObjectGroupId(Object** handle,
+                                     void* id) {
+  object_groups_->Add(ObjectGroupConnection(id, handle));
+}
+
+
+void GlobalHandles::SetRetainedObjectInfo(void* id,
+                                          RetainedObjectInfo* info) {
+  retained_object_infos_.Add(GroupRetainedObjectInfo(id, info));
+}
+
+
 void GlobalHandles::AddImplicitReferences(HeapObject** parent,
                                           Object*** children,
                                           size_t length) {
 #ifdef DEBUG
   ASSERT(!Node::FromLocation(BitCast<Object**>(parent))->is_independent());
   for (size_t i = 0; i < length; ++i) {
     ASSERT(!Node::FromLocation(children[i])->is_independent());
   }
 #endif
   if (length == 0) return;
   implicit_ref_groups_.Add(ImplicitRefGroup::New(parent, children, length));
 }
 
+List<ObjectGroup*>* GlobalHandles::object_groups() {

[Michael Starzinger, 2013/04/09 14:18:40]

This transferal of ownership of the structure looks mighty dangerous. Also I see
only one use-site of this method (i.e. heap snapshot creation). Could we just
use a second iterator that allows you to iterate over
<Object**,RetainedObjectInfo*> tuples instead of materializing this list here
just to delete it right after iteration again?

[marja, 2013/04/09 16:46:51]

I couldn't wrap my head around how to transfer the ownership of the Info in this
iterator-based approach, so I wrote a version which is closer to the existing
code (HeapSnapshotGenerator modifies directly the data structures of
GlobalHandles, and gets the Info, nullifies the pointer to it and so on). Wdyt?

+  List<ObjectGroup*>* to_return = new List<ObjectGroup*>();
+
+  object_groups_->Sort();
+  retained_object_infos_.Sort();
+  int retained_object_infos_ix = 0;
+
+  void* current_group_id = NULL;
+  size_t current_group_start = 0;
+
+  for (int i = 0; i <= object_groups_->length(); ++i) {
+    if (i == 0)
+      current_group_id = object_groups_->at(i).id;
+    if (i == object_groups_->length() ||
+        current_group_id != object_groups_->at(i).id) {
+      // Group detected: objects in indices [current_group_start, i[.
+      ObjectGroup* group = new ObjectGroup();
+      if (retained_object_infos_ix < retained_object_infos_.length() &&
+          retained_object_infos_[retained_object_infos_ix].id ==
+          object_groups_->at(current_group_start).id) {
+        // Transfer the ownership of info.
+        group->info = retained_object_infos_[retained_object_infos_ix].info;
+        retained_object_infos_[retained_object_infos_ix].info = NULL;
+        ++retained_object_infos_ix;
+      }
+      for (int j = current_group_start; j < i; ++j)
+        group->objects.Add(object_groups_->at(j).object);
+      to_return->Add(group);
+    }
+    if (i < object_groups_->length()) {
+      current_group_id = object_groups_->at(i).id;
+      current_group_start = i;
+    }
+  }
+  return to_return;
+}
 
 void GlobalHandles::RemoveObjectGroups() {
-  for (int i = 0; i < object_groups_.length(); i++) {
-    object_groups_.at(i)->Dispose();
+  object_groups_->Clear();
+  for (int i = 0; i < retained_object_infos_.length(); ++i) {
+    if (retained_object_infos_[i].info != NULL)
+      retained_object_infos_[i].info->Dispose();
   }
-  object_groups_.Clear();
+  retained_object_infos_.Clear();
 }
 
 
 void GlobalHandles::RemoveImplicitRefGroups() {
   for (int i = 0; i < implicit_ref_groups_.length(); i++) {
     implicit_ref_groups_.at(i)->Dispose();
   }
   implicit_ref_groups_.Clear();
 }
 
 
 void GlobalHandles::TearDown() {
   // TODO(1428): invoke weak callbacks.
 }
 
 
 } }  // namespace v8::internal