Revert "Retain maps for several garbage collections"

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/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 2107 matching lines @@
       if (!code->CanDeoptAt(it.frame()->pc())) {
         code->CodeIterateBody(visitor);
       }
       ProcessMarkingDeque();
       return;
     }
   }
 }
 
 
-void MarkCompactCollector::RetainMaps(ObjectVisitor* visitor) {
-  if (reduce_memory_footprint_ || abort_incremental_marking_ ||
-      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;
-  }
-
-  HeapObjectIterator map_iterator(heap()->map_space());
-  // The retaining counter goes from Map::kRetainingCounterStart
-  // down to Map::kRetainingCounterEnd. This range can be narrowed
-  // by the FLAG_retain_maps_for_n_gc flag.
-  int retaining_counter_end =
-      Max(Map::kRetainingCounterEnd,
-          Map::kRetainingCounterStart - FLAG_retain_maps_for_n_gc);
-  for (HeapObject* obj = map_iterator.Next(); obj != NULL;
-       obj = map_iterator.Next()) {
-    Map* map = Map::cast(obj);
-    MarkBit map_mark = Marking::MarkBitFrom(map);
-    int counter = map->counter();
-    if (!map_mark.Get()) {
-      if (counter > Map::kRetainingCounterStart ||
-          counter <= retaining_counter_end) {
-        // The counter is outside of retaining range. Do not retain this map.
-        continue;
-      }
-      Object* constructor = map->constructor();
-      if (!constructor->IsHeapObject() ||
-          !Marking::MarkBitFrom(HeapObject::cast(constructor)).Get()) {
-        // The constructor is dead, no new objects with this map can
-        // be created. Do not retain this map.
-        continue;
-      }
-      map->set_counter(counter - 1);
-      SetMark(map, map_mark);
-      MarkCompactMarkingVisitor::IterateBody(map->map(), map);
-    } else if (counter < Map::kRetainingCounterStart) {
-      // Reset the counter for live maps.
-      map->set_counter(Map::kRetainingCounterStart);
-    }
-  }
-  ProcessMarkingDeque();
-}
-
-
 void MarkCompactCollector::EnsureMarkingDequeIsCommittedAndInitialize() {
   if (marking_deque_memory_ == NULL) {
     marking_deque_memory_ = new base::VirtualMemory(4 * MB);
   }
   if (!marking_deque_memory_committed_) {
     bool success = marking_deque_memory_->Commit(
         reinterpret_cast<Address>(marking_deque_memory_->address()),
         marking_deque_memory_->size(),
         false);  // Not executable.
     CHECK(success);
@@ skipping 79 matching lines @@
         }
       }
     }
   }
 
   RootMarkingVisitor root_visitor(heap());
   MarkRoots(&root_visitor);
 
   ProcessTopOptimizedFrame(&root_visitor);
 
-  // Retaining dying maps should happen before or during ephemeral marking
-  // because a map could keep the key of an ephemeron alive. Note that map
-  // aging is imprecise: maps that are kept alive only by ephemerons will age.
-  RetainMaps(&root_visitor);
-
   {
     GCTracer::Scope gc_scope(heap()->tracer(), GCTracer::Scope::MC_WEAKCLOSURE);
 
     // The objects reachable from the roots are marked, yet unreachable
     // objects are unmarked.  Mark objects reachable due to host
     // application specific logic or through Harmony weak maps.
     ProcessEphemeralMarking(&root_visitor, false);
 
     // The objects reachable from the roots, weak maps or object groups
     // are marked. Objects pointed to only by weak global handles cannot be
@@ skipping 2205 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }
 }  // namespace v8::internal