Implement aging of maps embedded in optimized code.

src/heap/heap.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/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 1219 matching lines @@
   isolate_->compilation_cache()->MarkCompactPrologue();
 
   CompletelyClearInstanceofCache();
 
   FlushNumberStringCache();
   if (FLAG_cleanup_code_caches_at_gc) {
     polymorphic_code_cache()->set_cache(undefined_value());
   }
 
   ClearNormalizedMapCaches();
+
+  if (mark_compact_collector_.reduce_memory_footprint()) {
+    embedded_map_cache_ = undefined_value();
+  } else {
+    if (embedded_map_cache_->IsEmbeddedMapCache()) {
+      EmbeddedMapCache::cast(embedded_map_cache_)->Age();
+    }
+  }

[Hannes Payer (out of office), 2014/11/17 17:34:33]

Factor that code out into a function to keep the prologue simple, e.g.
AgeEmbeddedMapCache.

 }
 
 
 // Helper class for copying HeapObjects
 class ScavengeVisitor : public ObjectVisitor {
  public:
   explicit ScavengeVisitor(Heap* heap) : heap_(heap) {}
 
   void VisitPointer(Object** p) { ScavengePointer(p); }
 
@@ skipping 3652 matching lines @@
   // empty.  However the next thing we do is create the partial snapshot,
   // filling up the partial snapshot cache with objects it needs as we go.
   SerializerDeserializer::Iterate(isolate_, v);
   // We don't do a v->Synchronize call here, because in debug mode that will
   // output a flag to the snapshot.  However at this point the serializer and
   // deserializer are deliberately a little unsynchronized (see above) so the
   // checking of the sync flag in the snapshot would fail.
 }
 
 
+void Heap::IterateEmbeddedMapCache(ObjectVisitor* visitor) {
+  visitor->VisitPointer(&embedded_map_cache_);
+}
+
+
 // TODO(1236194): Since the heap size is configurable on the command line
 // and through the API, we should gracefully handle the case that the heap
 // size is not big enough to fit all the initial objects.
 bool Heap::ConfigureHeap(int max_semi_space_size, int max_old_space_size,
                          int max_executable_size, size_t code_range_size) {
   if (HasBeenSetUp()) return false;
 
   // Overwrite default configuration.
   if (max_semi_space_size > 0) {
     max_semi_space_size_ = max_semi_space_size * MB;
@@ skipping 350 matching lines @@
   CreateApiObjects();
 
   // Create initial objects
   CreateInitialObjects();
   CHECK_EQ(0, gc_count_);
 
   set_native_contexts_list(undefined_value());
   set_array_buffers_list(undefined_value());
   set_allocation_sites_list(undefined_value());
   weak_object_to_code_table_ = undefined_value();
+  embedded_map_cache_ = undefined_value();
   return true;
 }
 
 
 void Heap::SetStackLimits() {
   DCHECK(isolate_ != NULL);
   DCHECK(isolate_ == isolate());
   // On 64 bit machines, pointers are generally out of range of Smis.  We write
   // something that looks like an out of range Smi to the GC.
 
@@ skipping 190 matching lines @@
 
 void Heap::EnsureWeakObjectToCodeTable() {
   if (!weak_object_to_code_table()->IsHashTable()) {
     set_weak_object_to_code_table(
         *WeakHashTable::New(isolate(), 16, USE_DEFAULT_MINIMUM_CAPACITY,
                             TENURED));
   }
 }
 
 
+void Heap::CacheEmbeddedMap(Handle<Map> map) {
+  HandleScope scope(isolate());
+  if (!embedded_map_cache_->IsHashTable()) {
+    embedded_map_cache_ =
+        *EmbeddedMapCache::New(isolate(), 512, USE_DEFAULT_MINIMUM_CAPACITY,
+                               TENURED);
+  }
+  Handle<EmbeddedMapCache> cache(EmbeddedMapCache::cast(embedded_map_cache_),
+                                 isolate());
+  embedded_map_cache_ = *EmbeddedMapCache::Put(cache, map);
+}
+
+
 void Heap::FatalProcessOutOfMemory(const char* location, bool take_snapshot) {
   v8::internal::V8::FatalProcessOutOfMemory(location, take_snapshot);
 }
 
 #ifdef DEBUG
 
 class PrintHandleVisitor : public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++)
@@ skipping 764 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal