Implement aging of maps embedded in optimized code.

src/objects.cc

 // Copyright 2013 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 <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 14193 matching lines @@
 template class HashTable<StringTable, StringTableShape, HashTableKey*>;
 
 template class HashTable<CompilationCacheTable,
                          CompilationCacheShape,
                          HashTableKey*>;
 
 template class HashTable<ObjectHashTable,
                          ObjectHashTableShape,
                          Handle<Object> >;
 
-template class HashTable<WeakHashTable, WeakHashTableShape<2>, Handle<Object> >;
+template class HashTable<WeakHashTable, HeapPointerShape<2>, Handle<Object> >;
+
+template class HashTable<EmbeddedMapCache, HeapPointerShape<2>,
+                         Handle<Object> >;
 
 template class Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >;
 
 template class Dictionary<SeededNumberDictionary,
                           SeededNumberDictionaryShape,
                           uint32_t>;
 
 template class Dictionary<UnseededNumberDictionary,
                           UnseededNumberDictionaryShape,
                           uint32_t>;
@@ skipping 1458 matching lines @@
   DisallowHeapAllocation no_allocation;
   // TODO(ulan): Skipping write barrier is a temporary solution to avoid
   // memory leaks. Remove this once we have special visitor for weak fixed
   // arrays.
   set(EntryToIndex(entry), *key, SKIP_WRITE_BARRIER);
   set(EntryToValueIndex(entry), *value, SKIP_WRITE_BARRIER);
   ElementAdded();
 }
 
 
+Handle<EmbeddedMapCache> EmbeddedMapCache::Put(Handle<EmbeddedMapCache> table,
+                                               Handle<Map> key) {
+  DCHECK(table->IsKey(*key));
+  int entry = table->FindEntry(key);
+  // Key is already in table, just overwrite value.
+  if (entry != kNotFound) {
+    table->set(EntryToValueIndex(entry), Smi::FromInt(0), SKIP_WRITE_BARRIER);
+    return table;
+  }
+
+  // Check whether the hash table should be extended.
+  table = EnsureCapacity(table, 1, key, TENURED);
+  DisallowHeapAllocation no_allocation;
+  entry = table->FindInsertionEntry(table->Hash(key));
+  table->set(EntryToIndex(entry), *key);
+  table->set(EntryToValueIndex(entry), Smi::FromInt(0), SKIP_WRITE_BARRIER);
+  table->ElementAdded();
+  return table;
+}
+
+
+void EmbeddedMapCache::Age() {
+  int capacity = Capacity();
+  for (int i = 0; i < capacity; i++) {
+    Object* value = get(EntryToValueIndex(i));
+    if (value->IsSmi()) {
+      int age = Smi::cast(value)->value();
+      if (age > kMaxAge) {
+        set_the_hole(EntryToIndex(i));
+        set_the_hole(EntryToIndex(i) + 1);
+        ElementRemoved();
+      } else {
+        set(EntryToValueIndex(i), Smi::FromInt(age + 1), SKIP_WRITE_BARRIER);
+      }
+    }
+  }
+}
+
+
 template<class Derived, class Iterator, int entrysize>
 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Allocate(
     Isolate* isolate, int capacity, PretenureFlag pretenure) {
   // Capacity must be a power of two, since we depend on being able
   // to divide and multiple by 2 (kLoadFactor) to derive capacity
   // from number of buckets. If we decide to change kLoadFactor
   // to something other than 2, capacity should be stored as another
   // field of this object.
   capacity = base::bits::RoundUpToPowerOfTwo32(Max(kMinCapacity, capacity));
   if (capacity > kMaxCapacity) {
@@ skipping 961 matching lines @@
   Handle<DependentCode> codes =
       DependentCode::Insert(handle(cell->dependent_code(), info->isolate()),
                             DependentCode::kPropertyCellChangedGroup,
                             info->object_wrapper());
   if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
   info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
       cell, info->zone());
 }
 
 } }  // namespace v8::internal