Optimize ClearNonLiveReferences: collect dependent code only from maps that are embedded in optimize

src/heap/mark-compact.cc

 // Copyright 2012 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/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 331 matching lines @@
 
 void MarkCompactCollector::CollectGarbage() {
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
   DCHECK(state_ == PREPARE_GC);
 
   MarkLiveObjects();
 
   DCHECK(heap_->incremental_marking()->IsStopped());
 
-  // ClearNonLiveReferences can deoptimize code in dependent code arrays.
-  // Process weak cells before so that weak cells in dependent code
-  // arrays are cleared or contain only live code objects.
-  ProcessAndClearWeakCells();
-
-  ClearNonLiveReferences();
-
-  ClearWeakCollections();
-
-  heap_->set_encountered_weak_cells(Smi::FromInt(0));
+  ProcessWeakReferences();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     VerifyMarking(heap_);
   }
 #endif
 
   ClearInvalidStoreAndSlotsBufferEntries();
 
 #ifdef VERIFY_HEAP
@@ skipping 1442 matching lines @@
       if (!code->CanDeoptAt(it.frame()->pc())) {
         Code::BodyDescriptor::IterateBody(code, visitor);
       }
       ProcessMarkingDeque();
       return;
     }
   }
 }
 
 
+bool ShouldRetainMap(Map* map, int age) {
+  if (age == 0) {
+    // The map has aged. Do not retain this map.
+    return false;
+  }
+  Object* constructor = map->GetConstructor();
+  if (!constructor->IsHeapObject() ||
+      Marking::IsWhite(Marking::MarkBitFrom(HeapObject::cast(constructor)))) {
+    // The constructor is dead, no new objects with this map can
+    // be created. Do not retain this map.
+    return false;
+  }
+  return true;
+}
+
+
 void MarkCompactCollector::RetainMaps() {
-  if (heap()->ShouldReduceMemory() || heap()->ShouldAbortIncrementalMarking() ||
-      FLAG_retain_maps_for_n_gc == 0) {
-    // Do not retain dead maps if flag disables it or there is
-    // - memory pressure (reduce_memory_footprint_),
-    // - GC is requested by tests or dev-tools (abort_incremental_marking_).
-    return;
-  }
+  // Do not retain dead maps if flag disables it or there is
+  // - memory pressure (reduce_memory_footprint_),
+  // - GC is requested by tests or dev-tools (abort_incremental_marking_).
+  bool map_retaining_is_disabled = heap()->ShouldReduceMemory() ||
+                                   heap()->ShouldAbortIncrementalMarking() ||
+                                   FLAG_retain_maps_for_n_gc == 0;
 
   ArrayList* retained_maps = heap()->retained_maps();
   int length = retained_maps->Length();
   int new_length = 0;
+  // The number_of_disposed_maps separates maps in the retained_maps
+  // array that were created before and after context disposal.
+  // We do not age and retain disposed maps to avoid memory leaks.
+  int number_of_disposed_maps = heap()->number_of_disposed_maps_;
+  int new_number_of_disposed_maps = 0;
+  // This loop compacts the array by removing cleared weak cells,
+  // ages and retains dead maps.
   for (int i = 0; i < length; i += 2) {
     DCHECK(retained_maps->Get(i)->IsWeakCell());
     WeakCell* cell = WeakCell::cast(retained_maps->Get(i));
     if (cell->cleared()) continue;
     int age = Smi::cast(retained_maps->Get(i + 1))->value();
     int new_age;
     Map* map = Map::cast(cell->value());
     MarkBit map_mark = Marking::MarkBitFrom(map);
-    if (Marking::IsWhite(map_mark)) {
-      if (age == 0) {
-        // The map has aged. Do not retain this map.
-        continue;
-      }
-      Object* constructor = map->GetConstructor();
-      if (!constructor->IsHeapObject() || Marking::IsWhite(Marking::MarkBitFrom(
-                                              HeapObject::cast(constructor)))) {
-        // The constructor is dead, no new objects with this map can
-        // be created. Do not retain this map.
-        continue;
+    if (i >= number_of_disposed_maps && !map_retaining_is_disabled &&
+        Marking::IsWhite(map_mark)) {
+      if (ShouldRetainMap(map, age)) {
+        MarkObject(map, map_mark);
       }
       Object* prototype = map->prototype();
-      if (prototype->IsHeapObject() &&
+      if (age > 0 && prototype->IsHeapObject() &&
           Marking::IsWhite(Marking::MarkBitFrom(HeapObject::cast(prototype)))) {
         // The prototype is not marked, age the map.
         new_age = age - 1;
       } else {
         // The prototype and the constructor are marked, this map keeps only
         // transition tree alive, not JSObjects. Do not age the map.
         new_age = age;
       }
-      MarkObject(map, map_mark);
     } else {
       new_age = FLAG_retain_maps_for_n_gc;
     }
+    // Compact the array and update the age.
     if (i != new_length) {
       retained_maps->Set(new_length, cell);
       Object** slot = retained_maps->Slot(new_length);
       RecordSlot(retained_maps, slot, cell);
       retained_maps->Set(new_length + 1, Smi::FromInt(new_age));
     } else if (new_age != age) {
       retained_maps->Set(new_length + 1, Smi::FromInt(new_age));
     }
+    if (i < number_of_disposed_maps) {
+      new_number_of_disposed_maps++;
+    }
     new_length += 2;
   }
+  heap()->number_of_disposed_maps_ = new_number_of_disposed_maps;
   Object* undefined = heap()->undefined_value();
   for (int i = new_length; i < length; i++) {
     retained_maps->Clear(i, undefined);
   }
   if (new_length != length) retained_maps->SetLength(new_length);
   ProcessMarkingDeque();
 }
 
 
+DependentCode* MarkCompactCollector::DependentCodeListFromNonLiveMaps() {
+  GCTracer::Scope gc_scope(heap()->tracer(),
+                           GCTracer::Scope::MC_EXTRACT_DEPENDENT_CODE);
+  ArrayList* retained_maps = heap()->retained_maps();
+  int length = retained_maps->Length();
+  DependentCode* head = DependentCode::cast(heap()->empty_fixed_array());
+  for (int i = 0; i < length; i += 2) {
+    DCHECK(retained_maps->Get(i)->IsWeakCell());
+    WeakCell* cell = WeakCell::cast(retained_maps->Get(i));
+    DCHECK(!cell->cleared());
+    Map* map = Map::cast(cell->value());
+    MarkBit map_mark = Marking::MarkBitFrom(map);
+    if (Marking::IsWhite(map_mark)) {
+      DependentCode* candidate = map->dependent_code();
+      // We rely on the fact that the weak code group comes first.
+      STATIC_ASSERT(DependentCode::kWeakCodeGroup == 0);
+      if (candidate->length() > 0 &&
+          candidate->group() == DependentCode::kWeakCodeGroup) {
+        candidate->set_next_link(head);
+        head = candidate;
+      }
+    }
+  }
+  return head;
+}
+
+
 void MarkCompactCollector::EnsureMarkingDequeIsReserved() {
   DCHECK(!marking_deque_.in_use());
   if (marking_deque_memory_ == NULL) {
     marking_deque_memory_ = new base::VirtualMemory(kMaxMarkingDequeSize);
     marking_deque_memory_committed_ = 0;
   }
   if (marking_deque_memory_ == NULL) {
     V8::FatalProcessOutOfMemory("EnsureMarkingDequeIsReserved");
   }
 }
@@ skipping 286 matching lines @@
     }
 
     // Trim the optimized code map if entries have been removed.
     if (new_length < old_length) {
       shared->TrimOptimizedCodeMap(old_length - new_length);
     }
   }
 }
 
 
+void MarkCompactCollector::ProcessWeakReferences() {
+  // This should be done before processing weak cells because it checks
+  // mark bits of maps in weak cells.
+  DependentCode* dependent_code_list = DependentCodeListFromNonLiveMaps();
+
+  // Process weak cells before MarkCodeForDeoptimization and
+  // ClearNonLiveReferences  so that weak cells in dependent code arrays are
+  // cleared or contain only live code objects.
+  ProcessAndClearWeakCells();
+
+  MarkDependentCodeListForDeoptimization(dependent_code_list);
+
+  ClearNonLiveReferences();
+
+  ClearWeakCollections();
+
+  heap_->set_encountered_weak_cells(Smi::FromInt(0));
+}
+
+
 void MarkCompactCollector::ClearNonLiveReferences() {
   GCTracer::Scope gc_scope(heap()->tracer(),
                            GCTracer::Scope::MC_NONLIVEREFERENCES);
   // Iterate over the map space, setting map transitions that go from
   // a marked map to an unmarked map to null transitions.  This action
   // is carried out only on maps of JSObjects and related subtypes.
   HeapObjectIterator map_iterator(heap()->map_space());
   for (HeapObject* obj = map_iterator.Next(); obj != NULL;
        obj = map_iterator.Next()) {
     Map* map = Map::cast(obj);
     if (!map->CanTransition()) continue;
     MarkBit map_mark = Marking::MarkBitFrom(map);
     bool alive = Marking::IsBlackOrGrey(map_mark);
     if (alive) {
       ClearNonLivePrototypeTransitions(map);
     } else {
       ClearNonLiveMapTransitions(map);
-      have_code_to_deoptimize_ |=
-          map->dependent_code()->MarkCodeForDeoptimization(
-              isolate(), DependentCode::kWeakCodeGroup);
-      map->set_dependent_code(DependentCode::cast(heap()->empty_fixed_array()));
     }
   }
 
   WeakHashTable* table = heap_->weak_object_to_code_table();
   uint32_t capacity = table->Capacity();
   for (uint32_t i = 0; i < capacity; i++) {
     uint32_t key_index = table->EntryToIndex(i);
     Object* key = table->get(key_index);
     if (!table->IsKey(key)) continue;
     uint32_t value_index = table->EntryToValueIndex(i);
     Object* value = table->get(value_index);
     DCHECK(key->IsWeakCell());
     if (WeakCell::cast(key)->cleared()) {
       have_code_to_deoptimize_ |=
           DependentCode::cast(value)->MarkCodeForDeoptimization(
               isolate(), DependentCode::kWeakCodeGroup);
       table->set(key_index, heap_->the_hole_value());
       table->set(value_index, heap_->the_hole_value());
       table->ElementRemoved();
     }
   }
 }
 
 
+void MarkCompactCollector::MarkDependentCodeListForDeoptimization(
+    DependentCode* list_head) {
+  GCTracer::Scope gc_scope(heap()->tracer(),
+                           GCTracer::Scope::MC_DEOPT_DEPENDENT_CODE);
+  Isolate* isolate = this->isolate();
+  DependentCode* current = list_head;
+  while (current->length() > 0) {
+    have_code_to_deoptimize_ |= current->MarkCodeForDeoptimization(
+        isolate, DependentCode::kWeakCodeGroup);
+    current = current->next_link();
+  }
+}
+
+
 void MarkCompactCollector::ClearNonLivePrototypeTransitions(Map* map) {
   FixedArray* prototype_transitions =
       TransitionArray::GetPrototypeTransitions(map);
   int number_of_transitions =
       TransitionArray::NumberOfPrototypeTransitions(prototype_transitions);
 
   const int header = TransitionArray::kProtoTransitionHeaderSize;
   int new_number_of_transitions = 0;
   for (int i = 0; i < number_of_transitions; i++) {
     Object* cell = prototype_transitions->get(header + i);
@@ skipping 2237 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(&rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8