From: kaznacheev@chromium.org Date: Wed, 25 Aug 2010 13:25:54 +0000 (+0000) Subject: Reapplying r5147 (caching maps for slow case objects). X-Git-Tag: upstream/4.7.83~21293 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=6bd9d953dd9fdcc29bd9589fd84ff2ff2b2e0789;p=platform%2Fupstream%2Fv8.git Reapplying r5147 (caching maps for slow case objects). r5147 wrongly assumed that a code cache for a slow case map is always empty. This patch solves this: whenever we attempt to add a stub to a map's code cache we check that this map is cached. If it is we give the object its own copy of the map and only then modify the map. Review URL: http://codereview.chromium.org/3134027 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@5342 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc index ce8e98d..fd53673 100644 --- a/src/bootstrapper.cc +++ b/src/bootstrapper.cc @@ -232,6 +232,7 @@ class Genesis BASE_EMBEDDED { bool InstallNatives(); void InstallCustomCallGenerators(); void InstallJSFunctionResultCaches(); + void InitializeNormalizedMapCaches(); // Used both for deserialized and from-scratch contexts to add the extensions // provided. static bool InstallExtensions(Handle global_context, @@ -1400,6 +1401,13 @@ void Genesis::InstallJSFunctionResultCaches() { } +void Genesis::InitializeNormalizedMapCaches() { + Handle array( + Factory::NewFixedArray(NormalizedMapCache::kEntries, TENURED)); + global_context()->set_normalized_map_cache(NormalizedMapCache::cast(*array)); +} + + int BootstrapperActive::nesting_ = 0; @@ -1768,6 +1776,7 @@ Genesis::Genesis(Handle global_object, HookUpGlobalProxy(inner_global, global_proxy); InitializeGlobal(inner_global, empty_function); InstallJSFunctionResultCaches(); + InitializeNormalizedMapCaches(); if (!InstallNatives()) return; MakeFunctionInstancePrototypeWritable(); diff --git a/src/contexts.h b/src/contexts.h index 181efc9..2715fb9 100644 --- a/src/contexts.h +++ b/src/contexts.h @@ -86,6 +86,7 @@ enum ContextLookupFlags { V(CONFIGURE_GLOBAL_INDEX, JSFunction, configure_global_fun) \ V(FUNCTION_CACHE_INDEX, JSObject, function_cache) \ V(JSFUNCTION_RESULT_CACHES_INDEX, FixedArray, jsfunction_result_caches) \ + V(NORMALIZED_MAP_CACHE_INDEX, NormalizedMapCache, normalized_map_cache) \ V(RUNTIME_CONTEXT_INDEX, Context, runtime_context) \ V(CALL_AS_FUNCTION_DELEGATE_INDEX, JSFunction, call_as_function_delegate) \ V(CALL_AS_CONSTRUCTOR_DELEGATE_INDEX, JSFunction, \ @@ -211,6 +212,7 @@ class Context: public FixedArray { CONFIGURE_GLOBAL_INDEX, FUNCTION_CACHE_INDEX, JSFUNCTION_RESULT_CACHES_INDEX, + NORMALIZED_MAP_CACHE_INDEX, RUNTIME_CONTEXT_INDEX, CALL_AS_FUNCTION_DELEGATE_INDEX, CALL_AS_CONSTRUCTOR_DELEGATE_INDEX, diff --git a/src/heap.cc b/src/heap.cc index ff92384..6e696e7 100644 --- a/src/heap.cc +++ b/src/heap.cc @@ -571,6 +571,22 @@ void Heap::ClearJSFunctionResultCaches() { } +class ClearThreadNormalizedMapCachesVisitor: public ThreadVisitor { + virtual void VisitThread(ThreadLocalTop* top) { + Context* context = top->context_; + if (context == NULL) return; + context->global()->global_context()->normalized_map_cache()->Clear(); + } +}; + + +void Heap::ClearNormalizedMapCaches() { + if (Bootstrapper::IsActive()) return; + ClearThreadNormalizedMapCachesVisitor visitor; + ThreadManager::IterateArchivedThreads(&visitor); +} + + #ifdef DEBUG enum PageWatermarkValidity { @@ -755,6 +771,8 @@ void Heap::MarkCompactPrologue(bool is_compacting) { CompletelyClearInstanceofCache(); if (is_compacting) FlushNumberStringCache(); + + ClearNormalizedMapCaches(); } diff --git a/src/heap.h b/src/heap.h index 45fee17..5833c17 100644 --- a/src/heap.h +++ b/src/heap.h @@ -1021,6 +1021,8 @@ class Heap : public AllStatic { static void ClearJSFunctionResultCaches(); + static void ClearNormalizedMapCaches(); + static GCTracer* tracer() { return tracer_; } private: diff --git a/src/ic-inl.h b/src/ic-inl.h index 70bbaf8..94dbd5f 100644 --- a/src/ic-inl.h +++ b/src/ic-inl.h @@ -108,10 +108,10 @@ InlineCacheHolderFlag IC::GetCodeCacheForObject(JSObject* object, } -Map* IC::GetCodeCacheMap(Object* object, InlineCacheHolderFlag holder) { +JSObject* IC::GetCodeCacheHolder(Object* object, InlineCacheHolderFlag holder) { Object* map_owner = (holder == OWN_MAP ? object : object->GetPrototype()); ASSERT(map_owner->IsJSObject()); - return JSObject::cast(map_owner)->map(); + return JSObject::cast(map_owner); } diff --git a/src/ic.cc b/src/ic.cc index a5370a6..b4a333e 100644 --- a/src/ic.cc +++ b/src/ic.cc @@ -165,14 +165,14 @@ IC::State IC::StateFrom(Code* target, Object* receiver, Object* name) { if (cache_holder == OWN_MAP && !receiver->IsJSObject()) { // The stub was generated for JSObject but called for non-JSObject. - // IC::GetCodeCacheMap is not applicable. + // IC::GetCodeCacheHolder is not applicable. return MONOMORPHIC; } else if (cache_holder == PROTOTYPE_MAP && receiver->GetPrototype()->IsNull()) { - // IC::GetCodeCacheMap is not applicable. + // IC::GetCodeCacheHolder is not applicable. return MONOMORPHIC; } - Map* map = IC::GetCodeCacheMap(receiver, cache_holder); + Map* map = IC::GetCodeCacheHolder(receiver, cache_holder)->map(); // Decide whether the inline cache failed because of changes to the // receiver itself or changes to one of its prototypes. diff --git a/src/ic.h b/src/ic.h index a02f272..17450cc 100644 --- a/src/ic.h +++ b/src/ic.h @@ -123,8 +123,8 @@ class IC { JSObject* holder); static inline InlineCacheHolderFlag GetCodeCacheForObject(JSObject* object, JSObject* holder); - static inline Map* GetCodeCacheMap(Object* object, - InlineCacheHolderFlag holder); + static inline JSObject* GetCodeCacheHolder(Object* object, + InlineCacheHolderFlag holder); protected: Address fp() const { return fp_; } diff --git a/src/objects-debug.cc b/src/objects-debug.cc index 91aba26..6d49d75 100644 --- a/src/objects-debug.cc +++ b/src/objects-debug.cc @@ -30,6 +30,7 @@ #include "disassembler.h" #include "disasm.h" #include "jsregexp.h" +#include "objects-visiting.h" namespace v8 { namespace internal { @@ -648,6 +649,17 @@ void Map::MapVerify() { } +void Map::NormalizedMapVerify() { + MapVerify(); + ASSERT_EQ(Heap::empty_descriptor_array(), instance_descriptors()); + ASSERT_EQ(Heap::empty_fixed_array(), code_cache()); + ASSERT_EQ(0, pre_allocated_property_fields()); + ASSERT_EQ(0, unused_property_fields()); + ASSERT_EQ(StaticVisitorBase::GetVisitorId(instance_type(), instance_size()), + visitor_id()); +} + + void CodeCache::CodeCachePrint() { HeapObject::PrintHeader("CodeCache"); PrintF("\n - default_cache: "); @@ -1363,6 +1375,21 @@ void JSFunctionResultCache::JSFunctionResultCacheVerify() { } +void NormalizedMapCache::NormalizedMapCacheVerify() { + FixedArray::cast(this)->Verify(); + if (FLAG_enable_slow_asserts) { + for (int i = 0; i < length(); i++) { + Object* e = get(i); + if (e->IsMap()) { + Map::cast(e)->NormalizedMapVerify(); + } else { + ASSERT(e->IsUndefined()); + } + } + } +} + + #endif // DEBUG } } // namespace v8::internal diff --git a/src/objects-inl.h b/src/objects-inl.h index 005da60..ab4eefa 100644 --- a/src/objects-inl.h +++ b/src/objects-inl.h @@ -575,6 +575,18 @@ bool Object::IsJSFunctionResultCache() { } +bool Object::IsNormalizedMapCache() { + if (!IsFixedArray()) return false; + if (FixedArray::cast(this)->length() != NormalizedMapCache::kEntries) { + return false; + } +#ifdef DEBUG + reinterpret_cast(this)->NormalizedMapCacheVerify(); +#endif + return true; +} + + bool Object::IsCompilationCacheTable() { return IsHashTable(); } @@ -1660,6 +1672,7 @@ CAST_ACCESSOR(FixedArray) CAST_ACCESSOR(DescriptorArray) CAST_ACCESSOR(SymbolTable) CAST_ACCESSOR(JSFunctionResultCache) +CAST_ACCESSOR(NormalizedMapCache) CAST_ACCESSOR(CompilationCacheTable) CAST_ACCESSOR(CodeCacheHashTable) CAST_ACCESSOR(MapCache) diff --git a/src/objects.cc b/src/objects.cc index 1a4ed05..575ea9a 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -2098,6 +2098,124 @@ PropertyAttributes JSObject::GetLocalPropertyAttribute(String* name) { } +bool NormalizedMapCache::IsCacheable(JSObject* object) { + // Caching for global objects is not worth it (there are too few of them). + return !object->IsGlobalObject(); +} + + +Object* NormalizedMapCache::Get(JSObject* obj, PropertyNormalizationMode mode) { + Object* result; + + Map* fast = obj->map(); + if (!IsCacheable(obj)) { + result = fast->CopyNormalized(mode); + if (result->IsFailure()) return result; + } else { + int index = Hash(fast) % kEntries; + result = get(index); + + if (result->IsMap() && CheckHit(Map::cast(result), fast, mode)) { +#ifdef DEBUG + if (FLAG_enable_slow_asserts) { + // Make sure that the new slow map has exactly the same hash as the + // original fast map. This way we can use hash to check if a slow map + // is already in the hash (see Contains method). + ASSERT(Hash(fast) == Hash(Map::cast(result))); + // The cached map should match newly created normalized map bit-by-bit. + Object* fresh = fast->CopyNormalized(mode); + if (!fresh->IsFailure()) { + // Copy the unused byte so that the assertion below works. + Map::cast(fresh)->address()[Map::kUnusedOffset] = + Map::cast(result)->address()[Map::kUnusedOffset]; + ASSERT(memcmp(Map::cast(fresh)->address(), + Map::cast(result)->address(), + Map::kSize) == 0); + } + } +#endif + return result; + } + + result = fast->CopyNormalized(mode); + if (result->IsFailure()) return result; + set(index, result); + } + Counters::normalized_maps.Increment(); + + return result; +} + + +bool NormalizedMapCache::Contains(Map* map) { + // If the map is present in the cache it can only be at one place: + // at the index calculated from the hash. We assume that a slow map has the + // same hash as a fast map it has been generated from. + int index = Hash(map) % kEntries; + return get(index) == map; +} + + +void NormalizedMapCache::Clear() { + int entries = length(); + for (int i = 0; i != entries; i++) { + set_undefined(i); + } +} + + +int NormalizedMapCache::Hash(Map* fast) { + // For performance reasons we only hash the 3 most variable fields of a map: + // constructor, prototype and bit_field2. + + // Shift away the tag. + int hash = (static_cast( + reinterpret_cast(fast->constructor())) >> 2); + + // XOR-ing the prototype and constructor directly yields too many zero bits + // when the two pointers are close (which is fairly common). + // To avoid this we shift the prototype 4 bits relatively to the constructor. + hash ^= (static_cast( + reinterpret_cast(fast->prototype())) << 2); + + return hash ^ (hash >> 16) ^ fast->bit_field2(); +} + + +bool NormalizedMapCache::CheckHit(Map* slow, + Map* fast, + PropertyNormalizationMode mode) { +#ifdef DEBUG + slow->NormalizedMapVerify(); +#endif + return + slow->constructor() == fast->constructor() && + slow->prototype() == fast->prototype() && + slow->inobject_properties() == ((mode == CLEAR_INOBJECT_PROPERTIES) ? + 0 : + fast->inobject_properties()) && + slow->instance_type() == fast->instance_type() && + slow->bit_field() == fast->bit_field() && + slow->bit_field2() == fast->bit_field2(); +} + + +Object* JSObject::UpdateMapCodeCache(String* name, Code* code) { + if (!HasFastProperties() && + NormalizedMapCache::IsCacheable(this) && + Top::context()->global_context()->normalized_map_cache()-> + Contains(map())) { + // Replace the map with the identical copy that can be safely modified. + Object* obj = map()->CopyNormalized(KEEP_INOBJECT_PROPERTIES); + if (obj->IsFailure()) return obj; + Counters::normalized_maps.Increment(); + + set_map(Map::cast(obj)); + } + return map()->UpdateCodeCache(name, code); +} + + Object* JSObject::NormalizeProperties(PropertyNormalizationMode mode, int expected_additional_properties) { if (!HasFastProperties()) return this; @@ -2162,28 +2280,22 @@ Object* JSObject::NormalizeProperties(PropertyNormalizationMode mode, int index = map()->instance_descriptors()->NextEnumerationIndex(); dictionary->SetNextEnumerationIndex(index); - // Allocate new map. - obj = map()->CopyDropDescriptors(); + obj = Top::context()->global_context()-> + normalized_map_cache()->Get(this, mode); if (obj->IsFailure()) return obj; Map* new_map = Map::cast(obj); - // Clear inobject properties if needed by adjusting the instance size and - // putting in a filler object instead of the inobject properties. - if (mode == CLEAR_INOBJECT_PROPERTIES && map()->inobject_properties() > 0) { - int instance_size_delta = map()->inobject_properties() * kPointerSize; - int new_instance_size = map()->instance_size() - instance_size_delta; - new_map->set_inobject_properties(0); - new_map->set_instance_size(new_instance_size); - new_map->set_visitor_id(StaticVisitorBase::GetVisitorId(new_map)); - Heap::CreateFillerObjectAt(this->address() + new_instance_size, - instance_size_delta); - } - new_map->set_unused_property_fields(0); - // We have now successfully allocated all the necessary objects. // Changes can now be made with the guarantee that all of them take effect. + + // Resize the object in the heap if necessary. + int new_instance_size = new_map->instance_size(); + int instance_size_delta = map()->instance_size() - new_instance_size; + ASSERT(instance_size_delta >= 0); + Heap::CreateFillerObjectAt(this->address() + new_instance_size, + instance_size_delta); + set_map(new_map); - map()->set_instance_descriptors(Heap::empty_descriptor_array()); set_properties(dictionary); @@ -3083,6 +3195,33 @@ Object* Map::CopyDropDescriptors() { } +Object* Map::CopyNormalized(PropertyNormalizationMode mode) { + int new_instance_size = instance_size(); + if (mode == CLEAR_INOBJECT_PROPERTIES) { + new_instance_size -= inobject_properties() * kPointerSize; + } + + Object* result = Heap::AllocateMap(instance_type(), new_instance_size); + if (result->IsFailure()) return result; + + if (mode != CLEAR_INOBJECT_PROPERTIES) { + Map::cast(result)->set_inobject_properties(inobject_properties()); + } + + Map::cast(result)->set_prototype(prototype()); + Map::cast(result)->set_constructor(constructor()); + + Map::cast(result)->set_bit_field(bit_field()); + Map::cast(result)->set_bit_field2(bit_field2()); + +#ifdef DEBUG + Map::cast(result)->NormalizedMapVerify(); +#endif + + return result; +} + + Object* Map::CopyDropTransitions() { Object* new_map = CopyDropDescriptors(); if (new_map->IsFailure()) return new_map; diff --git a/src/objects.h b/src/objects.h index b23920c..ab8b271 100644 --- a/src/objects.h +++ b/src/objects.h @@ -638,6 +638,7 @@ class Object BASE_EMBEDDED { inline bool IsDictionary(); inline bool IsSymbolTable(); inline bool IsJSFunctionResultCache(); + inline bool IsNormalizedMapCache(); inline bool IsCompilationCacheTable(); inline bool IsCodeCacheHashTable(); inline bool IsMapCache(); @@ -1551,6 +1552,8 @@ class JSObject: public HeapObject { int expected_additional_properties); Object* NormalizeElements(); + Object* UpdateMapCodeCache(String* name, Code* code); + // Transform slow named properties to fast variants. // Returns failure if allocation failed. Object* TransformToFastProperties(int unused_property_fields); @@ -2465,6 +2468,35 @@ class JSFunctionResultCache: public FixedArray { }; +// The cache for maps used by normalized (dictionary mode) objects. +// Such maps do not have property descriptors, so a typical program +// needs very limited number of distinct normalized maps. +class NormalizedMapCache: public FixedArray { + public: + static const int kEntries = 64; + + static bool IsCacheable(JSObject* object); + + Object* Get(JSObject* object, PropertyNormalizationMode mode); + + bool Contains(Map* map); + + void Clear(); + + // Casting + static inline NormalizedMapCache* cast(Object* obj); + +#ifdef DEBUG + void NormalizedMapCacheVerify(); +#endif + + private: + static int Hash(Map* fast); + + static bool CheckHit(Map* slow, Map* fast, PropertyNormalizationMode mode); +}; + + // ByteArray represents fixed sized byte arrays. Used by the outside world, // such as PCRE, and also by the memory allocator and garbage collector to // fill in free blocks in the heap. @@ -3123,6 +3155,8 @@ class Map: public HeapObject { Object* CopyDropDescriptors(); + Object* CopyNormalized(PropertyNormalizationMode mode); + // Returns a copy of the map, with all transitions dropped from the // instance descriptors. Object* CopyDropTransitions(); @@ -3185,6 +3219,7 @@ class Map: public HeapObject { #ifdef DEBUG void MapPrint(); void MapVerify(); + void NormalizedMapVerify(); #endif inline int visitor_id(); @@ -3219,6 +3254,8 @@ class Map: public HeapObject { static const int kPreAllocatedPropertyFieldsOffset = kInstanceSizesOffset + kPreAllocatedPropertyFieldsByte; // The byte at position 3 is not in use at the moment. + static const int kUnusedByte = 3; + static const int kUnusedOffset = kInstanceSizesOffset + kUnusedByte; // Byte offsets within kInstanceAttributesOffset attributes. static const int kInstanceTypeOffset = kInstanceAttributesOffset + 0; diff --git a/src/stub-cache.cc b/src/stub-cache.cc index 54d9384..7a490d3 100644 --- a/src/stub-cache.cc +++ b/src/stub-cache.cc @@ -119,7 +119,7 @@ Object* StubCache::ComputeLoadNonexistent(String* name, JSObject* receiver) { if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), cache_name)); Object* result = - receiver->map()->UpdateCodeCache(cache_name, Code::cast(code)); + receiver->UpdateMapCodeCache(cache_name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -131,15 +131,14 @@ Object* StubCache::ComputeLoadField(String* name, JSObject* holder, int field_index) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { LoadStubCompiler compiler; code = compiler.CompileLoadField(receiver, holder, field_index, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -152,15 +151,14 @@ Object* StubCache::ComputeLoadCallback(String* name, AccessorInfo* callback) { ASSERT(v8::ToCData
(callback->getter()) != 0); ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { LoadStubCompiler compiler; code = compiler.CompileLoadCallback(name, receiver, holder, callback); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -172,16 +170,15 @@ Object* StubCache::ComputeLoadConstant(String* name, JSObject* holder, Object* value) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { LoadStubCompiler compiler; code = compiler.CompileLoadConstant(receiver, holder, value, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -192,15 +189,14 @@ Object* StubCache::ComputeLoadInterceptor(String* name, JSObject* receiver, JSObject* holder) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { LoadStubCompiler compiler; code = compiler.CompileLoadInterceptor(receiver, holder, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -218,9 +214,8 @@ Object* StubCache::ComputeLoadGlobal(String* name, JSGlobalPropertyCell* cell, bool is_dont_delete) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { LoadStubCompiler compiler; code = compiler.CompileLoadGlobal(receiver, @@ -230,7 +225,7 @@ Object* StubCache::ComputeLoadGlobal(String* name, is_dont_delete); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -242,15 +237,14 @@ Object* StubCache::ComputeKeyedLoadField(String* name, JSObject* holder, int field_index) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { KeyedLoadStubCompiler compiler; code = compiler.CompileLoadField(name, receiver, holder, field_index); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -262,16 +256,15 @@ Object* StubCache::ComputeKeyedLoadConstant(String* name, JSObject* holder, Object* value) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { KeyedLoadStubCompiler compiler; code = compiler.CompileLoadConstant(name, receiver, holder, value); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -282,16 +275,15 @@ Object* StubCache::ComputeKeyedLoadInterceptor(String* name, JSObject* receiver, JSObject* holder) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { KeyedLoadStubCompiler compiler; code = compiler.CompileLoadInterceptor(receiver, holder, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -303,16 +295,15 @@ Object* StubCache::ComputeKeyedLoadCallback(String* name, JSObject* holder, AccessorInfo* callback) { ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP); - Map* map = receiver->map(); Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { KeyedLoadStubCompiler compiler; code = compiler.CompileLoadCallback(name, receiver, holder, callback); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -325,14 +316,13 @@ Object* StubCache::ComputeKeyedLoadArrayLength(String* name, Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); ASSERT(receiver->IsJSObject()); - Map* map = receiver->map(); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { KeyedLoadStubCompiler compiler; code = compiler.CompileLoadArrayLength(name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -361,14 +351,13 @@ Object* StubCache::ComputeKeyedLoadFunctionPrototype(String* name, JSFunction* receiver) { Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); - Map* map = receiver->map(); - Object* code = map->FindInCodeCache(name, flags); + Object* code = receiver->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { KeyedLoadStubCompiler compiler; code = compiler.CompileLoadFunctionPrototype(name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -387,7 +376,7 @@ Object* StubCache::ComputeStoreField(String* name, code = compiler.CompileStoreField(receiver, field_index, transition, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); - Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -409,7 +398,7 @@ Object* StubCache::ComputeStoreGlobal(String* name, code = compiler.CompileStoreGlobal(receiver, cell, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); - Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -427,7 +416,7 @@ Object* StubCache::ComputeStoreCallback(String* name, code = compiler.CompileStoreCallback(receiver, callback, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); - Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -444,7 +433,7 @@ Object* StubCache::ComputeStoreInterceptor(String* name, code = compiler.CompileStoreInterceptor(receiver, name); if (code->IsFailure()) return code; PROFILE(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); - Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -462,7 +451,7 @@ Object* StubCache::ComputeKeyedStoreField(String* name, JSObject* receiver, if (code->IsFailure()) return code; PROFILE(CodeCreateEvent( Logger::KEYED_STORE_IC_TAG, Code::cast(code), name)); - Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); + Object* result = receiver->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -481,7 +470,7 @@ Object* StubCache::ComputeCallConstant(int argc, // Compute the check type and the map. InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(object, holder); - Map* map = IC::GetCodeCacheMap(object, cache_holder); + JSObject* map_holder = IC::GetCodeCacheHolder(object, cache_holder); // Compute check type based on receiver/holder. StubCompiler::CheckType check = StubCompiler::RECEIVER_MAP_CHECK; @@ -499,7 +488,7 @@ Object* StubCache::ComputeCallConstant(int argc, cache_holder, in_loop, argc); - Object* code = map->FindInCodeCache(name, flags); + Object* code = map_holder->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { // If the function hasn't been compiled yet, we cannot do it now // because it may cause GC. To avoid this issue, we return an @@ -513,7 +502,7 @@ Object* StubCache::ComputeCallConstant(int argc, ASSERT_EQ(flags, Code::cast(code)->flags()); PROFILE(CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = map_holder->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -530,7 +519,7 @@ Object* StubCache::ComputeCallField(int argc, // Compute the check type and the map. InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(object, holder); - Map* map = IC::GetCodeCacheMap(object, cache_holder); + JSObject* map_holder = IC::GetCodeCacheHolder(object, cache_holder); // TODO(1233596): We cannot do receiver map check for non-JS objects // because they may be represented as immediates without a @@ -544,7 +533,7 @@ Object* StubCache::ComputeCallField(int argc, cache_holder, in_loop, argc); - Object* code = map->FindInCodeCache(name, flags); + Object* code = map_holder->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { CallStubCompiler compiler(argc, in_loop, kind, cache_holder); code = compiler.CompileCallField(JSObject::cast(object), @@ -555,7 +544,7 @@ Object* StubCache::ComputeCallField(int argc, ASSERT_EQ(flags, Code::cast(code)->flags()); PROFILE(CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = map_holder->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -570,7 +559,7 @@ Object* StubCache::ComputeCallInterceptor(int argc, // Compute the check type and the map. InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(object, holder); - Map* map = IC::GetCodeCacheMap(object, cache_holder); + JSObject* map_holder = IC::GetCodeCacheHolder(object, cache_holder); // TODO(1233596): We cannot do receiver map check for non-JS objects // because they may be represented as immediates without a @@ -585,7 +574,7 @@ Object* StubCache::ComputeCallInterceptor(int argc, cache_holder, NOT_IN_LOOP, argc); - Object* code = map->FindInCodeCache(name, flags); + Object* code = map_holder->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { CallStubCompiler compiler(argc, NOT_IN_LOOP, kind, cache_holder); code = compiler.CompileCallInterceptor(JSObject::cast(object), @@ -595,7 +584,7 @@ Object* StubCache::ComputeCallInterceptor(int argc, ASSERT_EQ(flags, Code::cast(code)->flags()); PROFILE(CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = map_holder->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; @@ -623,14 +612,14 @@ Object* StubCache::ComputeCallGlobal(int argc, JSFunction* function) { InlineCacheHolderFlag cache_holder = IC::GetCodeCacheForObject(receiver, holder); - Map* map = IC::GetCodeCacheMap(receiver, cache_holder); + JSObject* map_holder = IC::GetCodeCacheHolder(receiver, cache_holder); Code::Flags flags = Code::ComputeMonomorphicFlags(kind, NORMAL, cache_holder, in_loop, argc); - Object* code = map->FindInCodeCache(name, flags); + Object* code = map_holder->map()->FindInCodeCache(name, flags); if (code->IsUndefined()) { // If the function hasn't been compiled yet, we cannot do it now // because it may cause GC. To avoid this issue, we return an @@ -643,7 +632,7 @@ Object* StubCache::ComputeCallGlobal(int argc, ASSERT_EQ(flags, Code::cast(code)->flags()); PROFILE(CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), Code::cast(code), name)); - Object* result = map->UpdateCodeCache(name, Code::cast(code)); + Object* result = map_holder->UpdateMapCodeCache(name, Code::cast(code)); if (result->IsFailure()) return result; } return code; diff --git a/src/v8-counters.h b/src/v8-counters.h index 2f2edfe..a7cb0ba 100644 --- a/src/v8-counters.h +++ b/src/v8-counters.h @@ -67,6 +67,7 @@ namespace internal { SC(pcre_mallocs, V8.PcreMallocCount) \ /* OS Memory allocated */ \ SC(memory_allocated, V8.OsMemoryAllocated) \ + SC(normalized_maps, V8.NormalizedMaps) \ SC(props_to_dictionary, V8.ObjectPropertiesToDictionary) \ SC(elements_to_dictionary, V8.ObjectElementsToDictionary) \ SC(alive_after_last_gc, V8.AliveAfterLastGC) \