Per-Isolate cache for polymorphic stubs

src/heap.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 833 matching lines @@
   // maps.
   isolate_->keyed_lookup_cache()->Clear();
   isolate_->context_slot_cache()->Clear();
   isolate_->descriptor_lookup_cache()->Clear();
 
   isolate_->compilation_cache()->MarkCompactPrologue();
 
   CompletelyClearInstanceofCache();
 
   if (is_compacting) FlushNumberStringCache();
+  if (FLAG_cleanup_code_caches_at_gc) {
+    polymorphic_code_cache()->set_cache(undefined_value());
+  }
 
   ClearNormalizedMapCaches();
 }
 
 
 Object* Heap::FindCodeObject(Address a) {
   Object* obj = NULL;  // Initialization to please compiler.
   { MaybeObject* maybe_obj = code_space_->FindObject(a);
     if (!maybe_obj->ToObject(&obj)) {
       obj = lo_space_->FindObject(a)->ToObjectUnchecked();
@@ skipping 763 matching lines @@
   { MaybeObject* maybe_result = AllocateStruct(CODE_CACHE_TYPE);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   CodeCache* code_cache = CodeCache::cast(result);
   code_cache->set_default_cache(empty_fixed_array());
   code_cache->set_normal_type_cache(undefined_value());
   return code_cache;
 }
 
 
+MaybeObject* Heap::AllocatePolymorphicCodeCache() {
+  Object* result;
+  { MaybeObject* maybe_result = AllocateStruct(POLYMORPHIC_CODE_CACHE_TYPE);
+    if (!maybe_result->ToObject(&result)) return maybe_result;
+  }
+  PolymorphicCodeCache* code_cache = PolymorphicCodeCache::cast(result);
+  code_cache->set_cache(undefined_value());

[Mads Ager (chromium), 2011/06/01 08:45:53]

You actually don't need this. Structs have all fields initialized with
undefined. You could just have a one-liner:

return AllocateStruct(POLYMORPHIC_CODE_CACHE_TYPE);

[Jakob Kummerow, 2011/06/01 10:15:27]

Nice! Done.

+  return code_cache;
+}
+
+
 const Heap::StringTypeTable Heap::string_type_table[] = {
 #define STRING_TYPE_ELEMENT(type, size, name, camel_name)                      \
   {type, size, k##camel_name##MapRootIndex},
   STRING_TYPE_LIST(STRING_TYPE_ELEMENT)
 #undef STRING_TYPE_ELEMENT
 };
 
 
 const Heap::ConstantSymbolTable Heap::constant_symbol_table[] = {
 #define CONSTANT_SYMBOL_ELEMENT(name, contents)                                \
@@ skipping 487 matching lines @@
   }
   set_code_stubs(NumberDictionary::cast(obj));
 
   // Allocate the non_monomorphic_cache used in stub-cache.cc. The initial size
   // is set to avoid expanding the dictionary during bootstrapping.
   { MaybeObject* maybe_obj = NumberDictionary::Allocate(64);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_non_monomorphic_cache(NumberDictionary::cast(obj));
 
+  { MaybeObject* maybe_obj = AllocatePolymorphicCodeCache();
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_polymorphic_code_cache(PolymorphicCodeCache::cast(obj));
+
   set_instanceof_cache_function(Smi::FromInt(0));
   set_instanceof_cache_map(Smi::FromInt(0));
   set_instanceof_cache_answer(Smi::FromInt(0));
 
   CreateFixedStubs();
 
   // Allocate the dictionary of intrinsic function names.
   { MaybeObject* maybe_obj = StringDictionary::Allocate(Runtime::kNumFunctions);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
@@ skipping 3769 matching lines @@
 }
 
 
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 } }  // namespace v8::internal