Changed scavenge GC to collect unmodified references

src/global-handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/global-handles.h"
 
 #include "src/api.h"
 #include "src/v8.h"
 #include "src/vm-state-inl.h"
 
@@ skipping 48 matching lines @@
 #ifdef ENABLE_HANDLE_ZAPPING
   ~Node() {
     // TODO(1428): if it's a weak handle we should have invoked its callback.
     // Zap the values for eager trapping.
     object_ = reinterpret_cast<Object*>(kGlobalHandleZapValue);
     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     index_ = 0;
     set_independent(false);
     set_partially_dependent(false);
     set_in_new_space_list(false);
+    set_unmodified(false);
     parameter_or_next_free_.next_free = NULL;
     weak_callback_ = NULL;
   }
 #endif
 
   void Initialize(int index, Node** first_free) {
     index_ = static_cast<uint8_t>(index);
     DCHECK(static_cast<int>(index_) == index);
     set_state(FREE);
     set_weakness_type(NORMAL_WEAK);
     set_in_new_space_list(false);
+    set_unmodified(false);
     parameter_or_next_free_.next_free = *first_free;
     *first_free = this;
   }
 
   void Acquire(Object* object) {
     DCHECK(state() == FREE);
     object_ = object;
     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     set_independent(false);
     set_partially_dependent(false);
+    set_unmodified(false);
     set_state(NORMAL);
     parameter_or_next_free_.parameter = NULL;
     weak_callback_ = NULL;
     IncreaseBlockUses();
   }
 
   void Zap() {
     DCHECK(IsInUse());
     // Zap the values for eager trapping.
     object_ = reinterpret_cast<Object*>(kGlobalHandleZapValue);
   }
 
   void Release() {
     DCHECK(IsInUse());
     set_state(FREE);
     // Zap the values for eager trapping.
     object_ = reinterpret_cast<Object*>(kGlobalHandleZapValue);
     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     set_independent(false);
     set_partially_dependent(false);
+    set_unmodified(false);
     weak_callback_ = NULL;
     DecreaseBlockUses();
   }
 
   // Object slot accessors.
   Object* object() const { return object_; }
   Object** location() { return &object_; }
   Handle<Object> handle() { return Handle<Object>(location()); }
 
   // Wrapper class ID accessors.
@@ skipping 26 matching lines @@
     flags_ = IsPartiallyDependent::update(flags_, v);
   }
 
   bool is_in_new_space_list() {
     return IsInNewSpaceList::decode(flags_);
   }
   void set_in_new_space_list(bool v) {
     flags_ = IsInNewSpaceList::update(flags_, v);
   }
 
+  bool is_unmodified() { return flag_unmodified_; }
+
+  void set_unmodified(bool v) { flag_unmodified_ = v; }
+
   WeaknessType weakness_type() const {
     return NodeWeaknessType::decode(flags_);
   }
   void set_weakness_type(WeaknessType weakness_type) {
     flags_ = NodeWeaknessType::update(flags_, weakness_type);
   }
 
   bool IsNearDeath() const {
     // Check for PENDING to ensure correct answer when processing callbacks.
     return state() == PENDING || state() == NEAR_DEATH;
@@ skipping 181 matching lines @@
 
   // This stores three flags (independent, partially_dependent and
   // in_new_space_list) and a State.
   class NodeState : public BitField<State, 0, 3> {};
   class IsIndependent : public BitField<bool, 3, 1> {};
   class IsPartiallyDependent : public BitField<bool, 4, 1> {};
   class IsInNewSpaceList : public BitField<bool, 5, 1> {};
   class NodeWeaknessType : public BitField<WeaknessType, 6, 2> {};
 
   uint8_t flags_;
+  // Merge this with flags_ later on. May be we need to extend flags_

[mythria, 2015/09/28 15:20:08]

I added a new field for the unmodified check.flags_ does not have any free bits
left. I am not sure if I should extend flags_ to 16 bits or just use a new
field.

[jochen (gone - plz use gerrit), 2015/09/28 15:56:19]

if the performance tests are looking good, we'll just rip the partially
dependent flag out...

+  bool flag_unmodified_;
 
   // Handle specific callback - might be a weak reference in disguise.
   WeakCallback weak_callback_;
 
   // Provided data for callback.  In FREE state, this is used for
   // the free list link.
   union {
     void* parameter;
     Node* next_free;
   } parameter_or_next_free_;
@@ skipping 274 matching lines @@
     }
   }
 }
 
 
 void GlobalHandles::IterateNewSpaceStrongAndDependentRoots(ObjectVisitor* v) {
   for (int i = 0; i < new_space_nodes_.length(); ++i) {
     Node* node = new_space_nodes_[i];
     if (node->IsStrongRetainer() ||
         (node->IsWeakRetainer() && !node->is_independent() &&
-         !node->is_partially_dependent())) {
+         !node->is_partially_dependent() && !node->is_unmodified())) {
         v->VisitPointer(node->location());
     }
   }
 }
 
 
 void GlobalHandles::IdentifyNewSpaceWeakIndependentHandles(
     WeakSlotCallbackWithHeap f) {
   for (int i = 0; i < new_space_nodes_.length(); ++i) {
     Node* node = new_space_nodes_[i];
@@ skipping 18 matching lines @@
         node->CollectPhantomCallbackData(isolate(),
                                          &pending_phantom_callbacks_);
       } else {
         v->VisitPointer(node->location());
       }
     }
   }
 }
 
 
+void GlobalHandles::IdentifyWeakUnmodifiedObjects(WeakSlotCallback f) {

[jochen (gone - plz use gerrit), 2015/09/28 15:56:19]

nit. f -> is_unmodified()

[mythria, 2015/10/02 15:29:16]

Done.

+  for (int i = 0; i < new_space_nodes_.length(); ++i) {
+    Node* node = new_space_nodes_[i];
+    if (node->IsWeak() && f(node->location())) {
+      node->set_partially_dependent(true);

[rmcilroy, 2015/09/28 17:32:46]

fix to set_unmodified(true);

[mythria, 2015/10/02 15:29:15]

Done.

+    }
+  }
+}
+
+
+void GlobalHandles::IdentifyNewSpaceWeakUnModifiedHandles(
+    WeakSlotCallbackWithHeap f) {

[jochen (gone - plz use gerrit), 2015/09/28 15:56:19]

f -> is_unscavenged

[mythria, 2015/10/02 15:29:15]

Done.

+  for (int i = 0; i < new_space_nodes_.length(); ++i) {
+    Node* node = new_space_nodes_[i];
+    DCHECK(node->is_in_new_space_list());
+    if ((node->is_independent() || node->is_unmodified()) && node->IsWeak() &&
+        f(isolate_->heap(), node->location())) {
+      node->MarkPending();
+    }
+  }
+}
+
+
+void GlobalHandles::IterateNewSpaceWeakUnModifiedRoots(ObjectVisitor* v) {
+  for (int i = 0; i < new_space_nodes_.length(); ++i) {
+    Node* node = new_space_nodes_[i];
+    DCHECK(node->is_in_new_space_list());
+    if ((node->is_independent() || node->is_unmodified()) &&
+        node->IsWeakRetainer()) {
+      // Pending weak phantom handles die immediately. Everything else survives.
+      if (node->state() == Node::PENDING &&
+          node->weakness_type() != NORMAL_WEAK) {
+        node->CollectPhantomCallbackData(isolate(),
+                                         &pending_phantom_callbacks_);
+      } else {
+        v->VisitPointer(node->location());
+      }
+    }
+  }
+}
+
+
 bool GlobalHandles::IterateObjectGroups(ObjectVisitor* v,
                                         WeakSlotCallbackWithHeap can_skip) {
   ComputeObjectGroupsAndImplicitReferences();
   int last = 0;
   bool any_group_was_visited = false;
   for (int i = 0; i < object_groups_.length(); i++) {
     ObjectGroup* entry = object_groups_.at(i);
     DCHECK(entry != NULL);
 
     Object*** objects = entry->objects;
@@ skipping 53 matching lines @@
     Node* node = new_space_nodes_[i];
     DCHECK(node->is_in_new_space_list());
     if (!node->IsRetainer()) {
       // Free nodes do not have weak callbacks. Do not use them to compute
       // the freed_nodes.
       continue;
     }
     // 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 (!node->is_independent() && !node->is_partially_dependent()) {
+    if (!node->is_independent() && !node->is_partially_dependent() &&
+        !node->is_unmodified()) {
       continue;
     }
     node->clear_partially_dependent();
     if (node->PostGarbageCollectionProcessing(isolate_)) {
       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).
         return freed_nodes;
@@ skipping 500 matching lines @@
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 }  // namespace internal
 }  // namespace v8