AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Introduce SimpleNumberDictionary.

Browse Source 
This is somewhat of a revival of what used to be
UnseededNumberDictionary. The difference to NumberDictionary is that
each entry only has two fields (no field for property details) and there
is no header field for a bitfield.

The reason for this change is memory regression introduced when we
removed UnseededNumberDictionary (6e1c57eaa9). We now use
SimpleNumberDictionary for
- slow template instantiation cache
- code stubs table
- value serializer map
- stack frame cache
- type profile source positions

R=ishell@chromium.org, ulan@chromium.org

Bug: chromium:783695
Change-Id: I3cd32e485060bb379fb2279eeefbbbded7455f0e
Reviewed-on: https://chromium-review.googlesource.com/885811
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#50869}
This commit is contained in:
Yang Guo 2018-01-25 09:42:56 +01:00 committed by Commit Bot
parent 664dc868b9
commit 3857b44e69
21 changed files with 237 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/api-natives.cc
View File

@ -285,10 +285,10 @@ MaybeHandle<JSObject> ProbeInstantiationsCache(Isolate* isolate,
} else if (caching_mode == CachingMode::kUnlimited ||
(serial_number <=
TemplateInfo::kSlowTemplateInstantiationsCacheSize)) {
Handle<NumberDictionary> slow_cache =
Handle<SimpleNumberDictionary> slow_cache =
isolate->slow_template_instantiations_cache();
int entry = slow_cache->FindEntry(serial_number);
if (entry == NumberDictionary::kNotFound) {
if (entry == SimpleNumberDictionary::kNotFound) {
return MaybeHandle<JSObject>();
}
return handle(JSObject::cast(slow_cache->ValueAt(entry)), isolate);
@ -313,9 +313,9 @@ void CacheTemplateInstantiation(Isolate* isolate, int serial_number,
} else if (caching_mode == CachingMode::kUnlimited ||
(serial_number <=
TemplateInfo::kSlowTemplateInstantiationsCacheSize)) {
Handle<NumberDictionary> cache =
Handle<SimpleNumberDictionary> cache =
isolate->slow_template_instantiations_cache();
auto new_cache = NumberDictionary::Set(cache, serial_number, object);
auto new_cache = SimpleNumberDictionary::Set(cache, serial_number, object);
if (*new_cache != *cache) {
isolate->native_context()->set_slow_template_instantiations_cache(
*new_cache);
@ -334,11 +334,11 @@ void UncacheTemplateInstantiation(Isolate* isolate, int serial_number,
} else if (caching_mode == CachingMode::kUnlimited ||
(serial_number <=
TemplateInfo::kSlowTemplateInstantiationsCacheSize)) {
Handle<NumberDictionary> cache =
Handle<SimpleNumberDictionary> cache =
isolate->slow_template_instantiations_cache();
int entry = cache->FindEntry(serial_number);
DCHECK_NE(NumberDictionary::kNotFound, entry);
cache = NumberDictionary::DeleteEntry(cache, entry);
DCHECK_NE(SimpleNumberDictionary::kNotFound, entry);
cache = SimpleNumberDictionary::DeleteEntry(cache, entry);
isolate->native_context()->set_slow_template_instantiations_cache(*cache);
}
}

4
src/bootstrapper.cc
View File

@ -4741,8 +4741,8 @@ bool Genesis::InstallNatives(GlobalContextType context_type) {
native_context()->set_fast_template_instantiations_cache(
*fast_template_instantiations_cache);
auto slow_template_instantiations_cache =
NumberDictionary::New(isolate(), ApiNatives::kInitialFunctionCacheSize);
auto slow_template_instantiations_cache = SimpleNumberDictionary::New(
isolate(), ApiNatives::kInitialFunctionCacheSize);
native_context()->set_slow_template_instantiations_cache(
*slow_template_instantiations_cache);

14
src/code-stubs.cc
View File

@ -71,9 +71,9 @@ void CodeStubDescriptor::Initialize(Register stack_parameter_count,
bool CodeStub::FindCodeInCache(Code** code_out) {
NumberDictionary* stubs = isolate()->heap()->code_stubs();
SimpleNumberDictionary* stubs = isolate()->heap()->code_stubs();
int index = stubs->FindEntry(isolate(), GetKey());
if (index != NumberDictionary::kNotFound) {
if (index != SimpleNumberDictionary::kNotFound) {
*code_out = Code::cast(stubs->ValueAt(index));
return true;
}
@ -97,10 +97,10 @@ void CodeStub::RecordCodeGeneration(Handle<Code> code) {
void CodeStub::DeleteStubFromCacheForTesting() {
Heap* heap = isolate_->heap();
Handle<NumberDictionary> dict(heap->code_stubs());
Handle<SimpleNumberDictionary> dict(heap->code_stubs());
int entry = dict->FindEntry(GetKey());
DCHECK_NE(NumberDictionary::kNotFound, entry);
dict = NumberDictionary::DeleteEntry(dict, entry);
DCHECK_NE(SimpleNumberDictionary::kNotFound, entry);
dict = SimpleNumberDictionary::DeleteEntry(dict, entry);
heap->SetRootCodeStubs(*dict);
}
@ -166,8 +166,8 @@ Handle<Code> CodeStub::GetCode() {
#endif
// Update the dictionary and the root in Heap.
Handle<NumberDictionary> dict =
NumberDictionary::Set(handle(heap->code_stubs()), GetKey(), new_object);
Handle<SimpleNumberDictionary> dict = SimpleNumberDictionary::Set(
handle(heap->code_stubs()), GetKey(), new_object);
heap->SetRootCodeStubs(*dict);
code = *new_object;
}

2
src/contexts.h
View File

@ -363,7 +363,7 @@ enum ContextLookupFlags {
slow_object_with_null_prototype_map) \
V(SLOW_OBJECT_WITH_OBJECT_PROTOTYPE_MAP, Map, \
slow_object_with_object_prototype_map) \
V(SLOW_TEMPLATE_INSTANTIATIONS_CACHE_INDEX, NumberDictionary, \
V(SLOW_TEMPLATE_INSTANTIATIONS_CACHE_INDEX, SimpleNumberDictionary, \
slow_template_instantiations_cache) \
/* All *_FUNCTION_MAP_INDEX definitions used by Context::FunctionMapIndex */ \
/* must remain together. */ \

2
src/factory.cc
View File

@ -2701,7 +2701,7 @@ Handle<StackFrameInfo> Factory::NewStackFrameInfo() {
Handle<SourcePositionTableWithFrameCache>
Factory::NewSourcePositionTableWithFrameCache(
Handle<ByteArray> source_position_table,
Handle<NumberDictionary> stack_frame_cache) {
Handle<SimpleNumberDictionary> stack_frame_cache) {
Handle<SourcePositionTableWithFrameCache>
source_position_table_with_frame_cache =
Handle<SourcePositionTableWithFrameCache>::cast(

2
src/factory.h
View File

@ -386,7 +386,7 @@ class V8_EXPORT_PRIVATE Factory final {
Handle<SourcePositionTableWithFrameCache>
NewSourcePositionTableWithFrameCache(
Handle<ByteArray> source_position_table,
Handle<NumberDictionary> stack_frame_cache);
Handle<SimpleNumberDictionary> stack_frame_cache);
// Foreign objects are pretenured when allocated by the bootstrapper.
Handle<Foreign> NewForeign(Address addr,

42
src/feedback-vector.cc
View File

@ -1115,26 +1115,26 @@ void CollectTypeProfileNexus::Collect(Handle<String> type, int position) {
Object* const feedback = GetFeedback();
// Map source position to collection of types
Handle<NumberDictionary> types;
Handle<SimpleNumberDictionary> types;
if (feedback == *FeedbackVector::UninitializedSentinel(isolate)) {
types = NumberDictionary::New(isolate, 1);
types = SimpleNumberDictionary::New(isolate, 1);
} else {
types = handle(NumberDictionary::cast(feedback));
types = handle(SimpleNumberDictionary::cast(feedback));
}
Handle<ArrayList> position_specific_types;
int entry = types->FindEntry(position);
if (entry == NumberDictionary::kNotFound) {
if (entry == SimpleNumberDictionary::kNotFound) {
position_specific_types = ArrayList::New(isolate, 1);
types = NumberDictionary::Set(
types = SimpleNumberDictionary::Set(
types, position, ArrayList::Add(position_specific_types, type));
} else {
DCHECK(types->ValueAt(entry)->IsArrayList());
position_specific_types = handle(ArrayList::cast(types->ValueAt(entry)));
if (!InList(position_specific_types, type)) { // Add type
types = NumberDictionary::Set(
types = SimpleNumberDictionary::Set(
types, position, ArrayList::Add(position_specific_types, type));
}
}
@ -1155,12 +1155,12 @@ std::vector<int> CollectTypeProfileNexus::GetSourcePositions() const {
return source_positions;
}
Handle<NumberDictionary> types =
Handle<NumberDictionary>(NumberDictionary::cast(feedback), isolate);
Handle<SimpleNumberDictionary> types = Handle<SimpleNumberDictionary>(
SimpleNumberDictionary::cast(feedback), isolate);
for (int index = NumberDictionary::kElementsStartIndex;
index < types->length(); index += NumberDictionary::kEntrySize) {
int key_index = index + NumberDictionary::kEntryKeyIndex;
for (int index = SimpleNumberDictionary::kElementsStartIndex;
index < types->length(); index += SimpleNumberDictionary::kEntrySize) {
int key_index = index + SimpleNumberDictionary::kEntryKeyIndex;
Object* key = types->get(key_index);
if (key->IsSmi()) {
int position = Smi::cast(key)->value();
@ -1180,11 +1180,11 @@ std::vector<Handle<String>> CollectTypeProfileNexus::GetTypesForSourcePositions(
return types_for_position;
}
Handle<NumberDictionary> types =
Handle<NumberDictionary>(NumberDictionary::cast(feedback), isolate);
Handle<SimpleNumberDictionary> types = Handle<SimpleNumberDictionary>(
SimpleNumberDictionary::cast(feedback), isolate);
int entry = types->FindEntry(position);
if (entry == NumberDictionary::kNotFound) {
if (entry == SimpleNumberDictionary::kNotFound) {
return types_for_position;
}
DCHECK(types->ValueAt(entry)->IsArrayList());
@ -1201,16 +1201,17 @@ std::vector<Handle<String>> CollectTypeProfileNexus::GetTypesForSourcePositions(
namespace {
Handle<JSObject> ConvertToJSObject(Isolate* isolate,
Handle<NumberDictionary> feedback) {
Handle<SimpleNumberDictionary> feedback) {
Handle<JSObject> type_profile =
isolate->factory()->NewJSObject(isolate->object_function());
for (int index = NumberDictionary::kElementsStartIndex;
index < feedback->length(); index += NumberDictionary::kEntrySize) {
int key_index = index + NumberDictionary::kEntryKeyIndex;
for (int index = SimpleNumberDictionary::kElementsStartIndex;
index < feedback->length();
index += SimpleNumberDictionary::kEntrySize) {
int key_index = index + SimpleNumberDictionary::kEntryKeyIndex;
Object* key = feedback->get(key_index);
if (key->IsSmi()) {
int value_index = index + NumberDictionary::kEntryValueIndex;
int value_index = index + SimpleNumberDictionary::kEntryValueIndex;
Handle<ArrayList> position_specific_types(
ArrayList::cast(feedback->get(value_index)));
@ -1237,7 +1238,8 @@ JSObject* CollectTypeProfileNexus::GetTypeProfile() const {
return *isolate->factory()->NewJSObject(isolate->object_function());
}
return *ConvertToJSObject(isolate, handle(NumberDictionary::cast(feedback)));
return *ConvertToJSObject(isolate,
handle(SimpleNumberDictionary::cast(feedback)));
}
} // namespace internal

1
src/globals.h
View File

@ -475,6 +475,7 @@ class FreeStoreAllocationPolicy;
class FunctionTemplateInfo;
class MemoryChunk;
class NumberDictionary;
class SimpleNumberDictionary;
class NameDictionary;
class GlobalDictionary;
template <typename T> class MaybeHandle;

2
src/heap/heap.cc
View File

@ -644,7 +644,7 @@ const char* Heap::GetSpaceName(int idx) {
return nullptr;
}
void Heap::SetRootCodeStubs(NumberDictionary* value) {
void Heap::SetRootCodeStubs(SimpleNumberDictionary* value) {
roots_[kCodeStubsRootIndex] = value;
}

6
src/heap/heap.h
View File

@ -114,6 +114,7 @@ using v8::MemoryPressureLevel;
V(Map, name_dictionary_map, NameDictionaryMap) \
V(Map, global_dictionary_map, GlobalDictionaryMap) \
V(Map, number_dictionary_map, NumberDictionaryMap) \
V(Map, simple_number_dictionary_map, SimpleNumberDictionaryMap) \
V(Map, string_table_map, StringTableMap) \
V(Map, weak_hash_table_map, WeakHashTableMap) \
V(Map, sloppy_arguments_elements_map, SloppyArgumentsElementsMap) \
@ -231,7 +232,7 @@ using v8::MemoryPressureLevel;
V(NameDictionary, api_symbol_table, ApiSymbolTable) \
V(NameDictionary, api_private_symbol_table, ApiPrivateSymbolTable) \
V(Object, script_list, ScriptList) \
V(NumberDictionary, code_stubs, CodeStubs) \
V(SimpleNumberDictionary, code_stubs, CodeStubs) \
V(FixedArray, materialized_objects, MaterializedObjects) \
V(FixedArray, microtask_queue, MicrotaskQueue) \
V(FixedArray, detached_contexts, DetachedContexts) \
@ -364,6 +365,7 @@ using v8::MemoryPressureLevel;
V(ScopeInfoMap) \
V(ScriptContextMap) \
V(SharedFunctionInfoMap) \
V(SimpleNumberDictionaryMap) \
V(SloppyArgumentsElementsMap) \
V(SmallOrderedHashMapMap) \
V(SmallOrderedHashSetMap) \
@ -1063,7 +1065,7 @@ class Heap {
Object** roots_array_start() { return roots_; }
// Sets the stub_cache_ (only used when expanding the dictionary).
void SetRootCodeStubs(NumberDictionary* value);
void SetRootCodeStubs(SimpleNumberDictionary* value);
void SetRootMaterializedObjects(FixedArray* objects) {
roots_[kMaterializedObjectsRootIndex] = objects;

3
src/heap/setup-heap-internal.cc
View File

@ -303,6 +303,7 @@ bool Heap::CreateInitialMaps() {
ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, name_dictionary)
ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, global_dictionary)
ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, number_dictionary)
ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, simple_number_dictionary)
ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, string_table)
ALLOCATE_VARSIZE_MAP(HASH_TABLE_TYPE, weak_hash_table)
@ -475,7 +476,7 @@ void Heap::CreateInitialObjects() {
// Create the code_stubs dictionary. The initial size is set to avoid
// expanding the dictionary during bootstrapping.
set_code_stubs(*NumberDictionary::New(isolate(), 128));
set_code_stubs(*SimpleNumberDictionary::New(isolate(), 128));
{
HandleScope scope(isolate());

10
src/isolate.cc
View File

@ -717,16 +717,16 @@ class CaptureStackTraceHelper {
int code_offset;
Handle<ByteArray> source_position_table;
Handle<Object> maybe_cache;
Handle<NumberDictionary> cache;
Handle<SimpleNumberDictionary> cache;
if (!FLAG_optimize_for_size) {
code_offset = summ.code_offset();
source_position_table =
handle(summ.abstract_code()->source_position_table(), isolate_);
maybe_cache = handle(summ.abstract_code()->stack_frame_cache(), isolate_);
if (maybe_cache->IsNumberDictionary()) {
cache = Handle<NumberDictionary>::cast(maybe_cache);
if (maybe_cache->IsSimpleNumberDictionary()) {
cache = Handle<SimpleNumberDictionary>::cast(maybe_cache);
} else {
cache = NumberDictionary::New(isolate_, 1);
cache = SimpleNumberDictionary::New(isolate_, 1);
}
int entry = cache->FindEntry(code_offset);
if (entry != NumberDictionary::kNotFound) {
@ -759,7 +759,7 @@ class CaptureStackTraceHelper {
frame->set_is_constructor(summ.is_constructor());
frame->set_is_wasm(false);
if (!FLAG_optimize_for_size) {
auto new_cache = NumberDictionary::Set(cache, code_offset, frame);
auto new_cache = SimpleNumberDictionary::Set(cache, code_offset, frame);
if (*new_cache != *cache || !maybe_cache->IsNumberDictionary()) {
AbstractCode::SetStackFrameCache(summ.abstract_code(), new_cache);
}

26
src/objects-inl.h
View File

@ -441,6 +441,10 @@ bool HeapObject::IsNumberDictionary() const {
return map() == GetHeap()->number_dictionary_map();
}
bool HeapObject::IsSimpleNumberDictionary() const {
return map() == GetHeap()->simple_number_dictionary_map();
}
bool HeapObject::IsStringTable() const {
return map() == GetHeap()->string_table_map();
}
@ -580,6 +584,7 @@ CAST_ACCESSOR(JSValue)
CAST_ACCESSOR(LayoutDescriptor)
CAST_ACCESSOR(NameDictionary)
CAST_ACCESSOR(NormalizedMapCache)
CAST_ACCESSOR(NumberDictionary)
CAST_ACCESSOR(Object)
CAST_ACCESSOR(ObjectHashSet)
CAST_ACCESSOR(ObjectHashTable)
@ -595,7 +600,7 @@ CAST_ACCESSOR(PropertyCell)
CAST_ACCESSOR(PrototypeInfo)
CAST_ACCESSOR(RegExpMatchInfo)
CAST_ACCESSOR(ScopeInfo)
CAST_ACCESSOR(NumberDictionary)
CAST_ACCESSOR(SimpleNumberDictionary)
CAST_ACCESSOR(SmallOrderedHashMap)
CAST_ACCESSOR(SmallOrderedHashSet)
CAST_ACCESSOR(Smi)
@ -2493,7 +2498,7 @@ SMI_ACCESSORS(StackFrameInfo, id, kIdIndex)
ACCESSORS(SourcePositionTableWithFrameCache, source_position_table, ByteArray,
kSourcePositionTableIndex)
ACCESSORS(SourcePositionTableWithFrameCache, stack_frame_cache,
NumberDictionary, kStackFrameCacheIndex)
SimpleNumberDictionary, kStackFrameCacheIndex)
SMI_ACCESSORS(FunctionTemplateInfo, length, kLengthOffset)
BOOL_ACCESSORS(FunctionTemplateInfo, flag, hidden_prototype,
@ -3303,30 +3308,35 @@ void GlobalDictionary::ValueAtPut(int entry, Object* value) {
set(EntryToIndex(entry), value);
}
bool NumberDictionaryShape::IsMatch(uint32_t key, Object* other) {
bool NumberDictionaryBaseShape::IsMatch(uint32_t key, Object* other) {
DCHECK(other->IsNumber());
return key == static_cast<uint32_t>(other->Number());
}
uint32_t NumberDictionaryShape::Hash(Isolate* isolate, uint32_t key) {
uint32_t NumberDictionaryBaseShape::Hash(Isolate* isolate, uint32_t key) {
return ComputeIntegerHash(key, isolate->heap()->HashSeed());
}
uint32_t NumberDictionaryShape::HashForObject(Isolate* isolate, Object* other) {
uint32_t NumberDictionaryBaseShape::HashForObject(Isolate* isolate,
Object* other) {
DCHECK(other->IsNumber());
return ComputeIntegerHash(static_cast<uint32_t>(other->Number()),
isolate->heap()->HashSeed());
}
Handle<Object> NumberDictionaryBaseShape::AsHandle(Isolate* isolate,
uint32_t key) {
return isolate->factory()->NewNumberFromUint(key);
}
int NumberDictionaryShape::GetMapRootIndex() {
return Heap::kNumberDictionaryMapRootIndex;
}
Handle<Object> NumberDictionaryShape::AsHandle(Isolate* isolate, uint32_t key) {
return isolate->factory()->NewNumberFromUint(key);
int SimpleNumberDictionaryShape::GetMapRootIndex() {
return Heap::kSimpleNumberDictionaryMapRootIndex;
}
bool NameDictionaryShape::IsMatch(Handle<Name> key, Object* other) {
DCHECK(other->IsTheHole(key->GetIsolate()) ||
Name::cast(other)->IsUniqueName());

36
src/objects.cc
View File

@ -3612,7 +3612,8 @@ bool HeapObject::CanBeRehashed() const {
case HASH_TABLE_TYPE:
// TODO(yangguo): actually support rehashing OrderedHash{Map,Set}.
return IsNameDictionary() || IsGlobalDictionary() ||
IsNumberDictionary() || IsStringTable() || IsWeakHashTable();
IsNumberDictionary() || IsSimpleNumberDictionary() ||
IsStringTable() || IsWeakHashTable();
case DESCRIPTOR_ARRAY_TYPE:
return true;
case TRANSITION_ARRAY_TYPE:
@ -3634,6 +3635,8 @@ void HeapObject::RehashBasedOnMap() {
NameDictionary::cast(this)->Rehash();
} else if (IsNumberDictionary()) {
NumberDictionary::cast(this)->Rehash();
} else if (IsSimpleNumberDictionary()) {
SimpleNumberDictionary::cast(this)->Rehash();
} else if (IsGlobalDictionary()) {
GlobalDictionary::cast(this)->Rehash();
} else if (IsStringTable()) {
@ -14051,7 +14054,7 @@ SafepointEntry Code::GetSafepointEntry(Address pc) {
namespace {
template <typename Code>
void SetStackFrameCacheCommon(Handle<Code> code,
Handle<NumberDictionary> cache) {
Handle<SimpleNumberDictionary> cache) {
Handle<Object> maybe_table(code->source_position_table(), code->GetIsolate());
if (maybe_table->IsSourcePositionTableWithFrameCache()) {
Handle<SourcePositionTableWithFrameCache>::cast(maybe_table)
@ -14069,7 +14072,7 @@ void SetStackFrameCacheCommon(Handle<Code> code,
// static
void AbstractCode::SetStackFrameCache(Handle<AbstractCode> abstract_code,
Handle<NumberDictionary> cache) {
Handle<SimpleNumberDictionary> cache) {
if (abstract_code->IsCode()) {
SetStackFrameCacheCommon(handle(abstract_code->GetCode()), cache);
} else {
@ -16444,6 +16447,12 @@ template class EXPORT_TEMPLATE_DEFINE(
template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
Dictionary<NumberDictionary, NumberDictionaryShape>;
template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
HashTable<SimpleNumberDictionary, SimpleNumberDictionaryShape>;
template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
Dictionary<SimpleNumberDictionary, SimpleNumberDictionaryShape>;
template Handle<NameDictionary>
BaseNameDictionary<NameDictionary, NameDictionaryShape>::New(
Isolate*, int n, PretenureFlag pretenure, MinimumCapacity capacity_option);
@ -16456,6 +16465,11 @@ template Handle<NumberDictionary>
Dictionary<NumberDictionary, NumberDictionaryShape>::AtPut(
Handle<NumberDictionary>, uint32_t, Handle<Object>, PropertyDetails);
template Handle<SimpleNumberDictionary>
Dictionary<SimpleNumberDictionary, SimpleNumberDictionaryShape>::AtPut(
Handle<SimpleNumberDictionary>, uint32_t, Handle<Object>,
PropertyDetails);
template Object* Dictionary<
NumberDictionary, NumberDictionaryShape>::SlowReverseLookup(Object* value);
@ -16470,6 +16484,10 @@ template Handle<NumberDictionary>
Dictionary<NumberDictionary, NumberDictionaryShape>::DeleteEntry(
Handle<NumberDictionary>, int);
template Handle<SimpleNumberDictionary>
Dictionary<SimpleNumberDictionary, SimpleNumberDictionaryShape>::DeleteEntry(
Handle<SimpleNumberDictionary>, int);
template Handle<NameDictionary>
HashTable<NameDictionary, NameDictionaryShape>::New(Isolate*, int,
PretenureFlag,
@ -16503,6 +16521,11 @@ template Handle<NameDictionary>
BaseNameDictionary<NameDictionary, NameDictionaryShape>::EnsureCapacity(
Handle<NameDictionary>, int);
template Handle<SimpleNumberDictionary>
Dictionary<SimpleNumberDictionary, SimpleNumberDictionaryShape>::Add(
Handle<SimpleNumberDictionary>, uint32_t, Handle<Object>, PropertyDetails,
int*);
template int Dictionary<GlobalDictionary,
GlobalDictionaryShape>::NumberOfEnumerableProperties();
@ -17587,6 +17610,13 @@ Handle<Derived> Dictionary<Derived, Shape>::Add(Handle<Derived> dictionary,
return dictionary;
}
// static
Handle<SimpleNumberDictionary> SimpleNumberDictionary::Set(
Handle<SimpleNumberDictionary> dictionary, uint32_t key,
Handle<Object> value) {
return AtPut(dictionary, key, value, PropertyDetails::Empty());
}
bool NumberDictionary::HasComplexElements() {
if (!requires_slow_elements()) return false;
Isolate* isolate = this->GetIsolate();

5
src/objects.h
View File

@ -1048,6 +1048,7 @@ template <class C> inline bool Is(Object* obj);
V(NameDictionary) \
V(NativeContext) \
V(NormalizedMapCache) \
V(NumberDictionary) \
V(ObjectHashSet) \
V(ObjectHashTable) \
V(Oddball) \
@ -1061,11 +1062,11 @@ template <class C> inline bool Is(Object* obj);
V(RegExpMatchInfo) \
V(ScopeInfo) \
V(ScriptContextTable) \
V(NumberDictionary) \
V(SeqOneByteString) \
V(SeqString) \
V(SeqTwoByteString) \
V(SharedFunctionInfo) \
V(SimpleNumberDictionary) \
V(SlicedString) \
V(SloppyArgumentsElements) \
V(SmallOrderedHashMap) \
@ -4996,7 +4997,7 @@ class StackFrameInfo : public Struct {
class SourcePositionTableWithFrameCache : public Tuple2 {
public:
DECL_ACCESSORS(source_position_table, ByteArray)
DECL_ACCESSORS(stack_frame_cache, NumberDictionary)
DECL_ACCESSORS(stack_frame_cache, SimpleNumberDictionary)
DECL_CAST(SourcePositionTableWithFrameCache)

2
src/objects/code.h
View File

@ -584,7 +584,7 @@ class AbstractCode : public HeapObject {
inline Object* stack_frame_cache();
static void SetStackFrameCache(Handle<AbstractCode> abstract_code,
Handle<NumberDictionary> cache);
Handle<SimpleNumberDictionary> cache);
void DropStackFrameCache();
// Returns the size of instructions and the metadata.

52
src/objects/dictionary.h
View File

@ -228,26 +228,70 @@ class GlobalDictionary
inline void ValueAtPut(int entry, Object* value);
};
class NumberDictionaryShape : public BaseDictionaryShape<uint32_t> {
class NumberDictionaryBaseShape : public BaseDictionaryShape<uint32_t> {
public:
static const int kPrefixSize = 1;
static const int kEntrySize = 3;
static inline bool IsMatch(uint32_t key, Object* other);
static inline Handle<Object> AsHandle(Isolate* isolate, uint32_t key);
static inline uint32_t Hash(Isolate* isolate, uint32_t key);
static inline uint32_t HashForObject(Isolate* isolate, Object* object);
};
class NumberDictionaryShape : public NumberDictionaryBaseShape {
public:
static const int kPrefixSize = 1;
static const int kEntrySize = 3;
static inline int GetMapRootIndex();
};
class SimpleNumberDictionaryShape : public NumberDictionaryBaseShape {
public:
static const bool kHasDetails = false;
static const int kPrefixSize = 0;
static const int kEntrySize = 2;
template <typename Dictionary>
static inline PropertyDetails DetailsAt(Dictionary* dict, int entry) {
UNREACHABLE();
}
template <typename Dictionary>
static inline void DetailsAtPut(Dictionary* dict, int entry,
PropertyDetails value) {
UNREACHABLE();
}
static inline int GetMapRootIndex();
};
extern template class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE)
HashTable<SimpleNumberDictionary, SimpleNumberDictionaryShape>;
extern template class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE)
Dictionary<SimpleNumberDictionary, SimpleNumberDictionaryShape>;
// SimpleNumberDictionary is used to map number to an entry.
class SimpleNumberDictionary
: public Dictionary<SimpleNumberDictionary, SimpleNumberDictionaryShape> {
public:
DECL_CAST(SimpleNumberDictionary)
// Type specific at put (default NONE attributes is used when adding).
MUST_USE_RESULT static Handle<SimpleNumberDictionary> Set(
Handle<SimpleNumberDictionary> dictionary, uint32_t key,
Handle<Object> value);
static const int kEntryValueIndex = 1;
};
extern template class EXPORT_TEMPLATE_DECLARE(
V8_EXPORT_PRIVATE) HashTable<NumberDictionary, NumberDictionaryShape>;
extern template class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE)
Dictionary<NumberDictionary, NumberDictionaryShape>;
// NumberDictionary is used as elements backing store and provides a bitfield
// and stores property details for every entry.
class NumberDictionary
: public Dictionary<NumberDictionary, NumberDictionaryShape> {
public:

14
src/value-serializer.cc
View File

@ -1084,13 +1084,13 @@ bool ValueDeserializer::ReadRawBytes(size_t length, const void** data) {
void ValueDeserializer::TransferArrayBuffer(
uint32_t transfer_id, Handle<JSArrayBuffer> array_buffer) {
if (array_buffer_transfer_map_.is_null()) {
array_buffer_transfer_map_ =
isolate_->global_handles()->Create(*NumberDictionary::New(isolate_, 0));
array_buffer_transfer_map_ = isolate_->global_handles()->Create(
*SimpleNumberDictionary::New(isolate_, 0));
}
Handle<NumberDictionary> dictionary =
Handle<SimpleNumberDictionary> dictionary =
array_buffer_transfer_map_.ToHandleChecked();
Handle<NumberDictionary> new_dictionary =
NumberDictionary::Set(dictionary, transfer_id, array_buffer);
Handle<SimpleNumberDictionary> new_dictionary =
SimpleNumberDictionary::Set(dictionary, transfer_id, array_buffer);
if (!new_dictionary.is_identical_to(dictionary)) {
GlobalHandles::Destroy(Handle<Object>::cast(dictionary).location());
array_buffer_transfer_map_ =
@ -1613,13 +1613,13 @@ MaybeHandle<JSArrayBuffer> ValueDeserializer::ReadJSArrayBuffer(
MaybeHandle<JSArrayBuffer> ValueDeserializer::ReadTransferredJSArrayBuffer() {
uint32_t id = next_id_++;
uint32_t transfer_id;
Handle<NumberDictionary> transfer_map;
Handle<SimpleNumberDictionary> transfer_map;
if (!ReadVarint<uint32_t>().To(&transfer_id) ||
!array_buffer_transfer_map_.ToHandle(&transfer_map)) {
return MaybeHandle<JSArrayBuffer>();
}
int index = transfer_map->FindEntry(isolate_, transfer_id);
if (index == NumberDictionary::kNotFound) {
if (index == SimpleNumberDictionary::kNotFound) {
return MaybeHandle<JSArrayBuffer>();
}
Handle<JSArrayBuffer> array_buffer(

2
src/value-serializer.h
View File

@ -301,7 +301,7 @@ class ValueDeserializer {
// Always global handles.
Handle<FixedArray> id_map_;
MaybeHandle<NumberDictionary> array_buffer_transfer_map_;
MaybeHandle<SimpleNumberDictionary> array_buffer_transfer_map_;
DISALLOW_COPY_AND_ASSIGN(ValueDeserializer);
};

5
tools/gen-postmortem-metadata.py
View File

@ -226,6 +226,11 @@ consts_misc = [
'value': 'NumberDictionaryShape::kPrefixSize' },
{ 'name': 'numberdictionaryshape_entry_size',
'value': 'NumberDictionaryShape::kEntrySize' },
{ 'name': 'simplenumberdictionaryshape_prefix_size',
'value': 'SimpleNumberDictionaryShape::kPrefixSize' },
{ 'name': 'simplenumberdictionaryshape_entry_size',
'value': 'SimpleNumberDictionaryShape::kEntrySize' },
];
#

133
tools/v8heapconst.py
View File

@ -214,72 +214,73 @@ KNOWN_MAPS = {
0x030b1: (173, "NameDictionaryMap"),
0x03101: (173, "GlobalDictionaryMap"),
0x03151: (173, "NumberDictionaryMap"),
0x031a1: (173, "StringTableMap"),
0x031f1: (173, "WeakHashTableMap"),
0x03241: (171, "SloppyArgumentsElementsMap"),
0x03291: (182, "SmallOrderedHashMapMap"),
0x032e1: (183, "SmallOrderedHashSetMap"),
0x03331: (176, "CodeDataContainerMap"),
0x03381: (1071, "JSMessageObjectMap"),
0x033d1: (1057, "ExternalMap"),
0x03421: (137, "BytecodeArrayMap"),
0x03471: (171, "ModuleInfoMap"),
0x034c1: (175, "NoClosuresCellMap"),
0x03511: (175, "OneClosureCellMap"),
0x03561: (175, "ManyClosuresCellMap"),
0x035b1: (179, "PropertyArrayMap"),
0x03601: (130, "BigIntMap"),
0x03651: (106, "NativeSourceStringMap"),
0x036a1: (64, "StringMap"),
0x036f1: (73, "ConsOneByteStringMap"),
0x03741: (65, "ConsStringMap"),
0x03791: (77, "ThinOneByteStringMap"),
0x037e1: (69, "ThinStringMap"),
0x03831: (67, "SlicedStringMap"),
0x03881: (75, "SlicedOneByteStringMap"),
0x038d1: (66, "ExternalStringMap"),
0x03921: (82, "ExternalStringWithOneByteDataMap"),
0x03971: (74, "ExternalOneByteStringMap"),
0x039c1: (98, "ShortExternalStringMap"),
0x03a11: (114, "ShortExternalStringWithOneByteDataMap"),
0x03a61: (0, "InternalizedStringMap"),
0x03ab1: (2, "ExternalInternalizedStringMap"),
0x03b01: (18, "ExternalInternalizedStringWithOneByteDataMap"),
0x03b51: (10, "ExternalOneByteInternalizedStringMap"),
0x03ba1: (34, "ShortExternalInternalizedStringMap"),
0x03bf1: (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
0x03c41: (42, "ShortExternalOneByteInternalizedStringMap"),
0x03c91: (106, "ShortExternalOneByteStringMap"),
0x03ce1: (140, "FixedUint8ArrayMap"),
0x03d31: (139, "FixedInt8ArrayMap"),
0x03d81: (142, "FixedUint16ArrayMap"),
0x03dd1: (141, "FixedInt16ArrayMap"),
0x03e21: (144, "FixedUint32ArrayMap"),
0x03e71: (143, "FixedInt32ArrayMap"),
0x03ec1: (145, "FixedFloat32ArrayMap"),
0x03f11: (146, "FixedFloat64ArrayMap"),
0x03f61: (147, "FixedUint8ClampedArrayMap"),
0x03fb1: (169, "Tuple2Map"),
0x04001: (167, "ScriptMap"),
0x04051: (160, "InterceptorInfoMap"),
0x040a1: (151, "AccessorInfoMap"),
0x040f1: (150, "AccessCheckInfoMap"),
0x04141: (152, "AccessorPairMap"),
0x04191: (153, "AliasedArgumentsEntryMap"),
0x041e1: (154, "AllocationMementoMap"),
0x04231: (155, "AllocationSiteMap"),
0x04281: (156, "AsyncGeneratorRequestMap"),
0x042d1: (157, "ContextExtensionMap"),
0x04321: (158, "DebugInfoMap"),
0x04371: (159, "FunctionTemplateInfoMap"),
0x043c1: (161, "ModuleInfoEntryMap"),
0x04411: (162, "ModuleMap"),
0x04461: (163, "ObjectTemplateInfoMap"),
0x044b1: (164, "PromiseReactionJobInfoMap"),
0x04501: (165, "PromiseResolveThenableJobInfoMap"),
0x04551: (166, "PrototypeInfoMap"),
0x045a1: (168, "StackFrameInfoMap"),
0x045f1: (170, "Tuple3Map"),
0x031a1: (173, "SimpleNumberDictionaryMap"),
0x031f1: (173, "StringTableMap"),
0x03241: (173, "WeakHashTableMap"),
0x03291: (171, "SloppyArgumentsElementsMap"),
0x032e1: (182, "SmallOrderedHashMapMap"),
0x03331: (183, "SmallOrderedHashSetMap"),
0x03381: (176, "CodeDataContainerMap"),
0x033d1: (1071, "JSMessageObjectMap"),
0x03421: (1057, "ExternalMap"),
0x03471: (137, "BytecodeArrayMap"),
0x034c1: (171, "ModuleInfoMap"),
0x03511: (175, "NoClosuresCellMap"),
0x03561: (175, "OneClosureCellMap"),
0x035b1: (175, "ManyClosuresCellMap"),
0x03601: (179, "PropertyArrayMap"),
0x03651: (130, "BigIntMap"),
0x036a1: (106, "NativeSourceStringMap"),
0x036f1: (64, "StringMap"),
0x03741: (73, "ConsOneByteStringMap"),
0x03791: (65, "ConsStringMap"),
0x037e1: (77, "ThinOneByteStringMap"),
0x03831: (69, "ThinStringMap"),
0x03881: (67, "SlicedStringMap"),
0x038d1: (75, "SlicedOneByteStringMap"),
0x03921: (66, "ExternalStringMap"),
0x03971: (82, "ExternalStringWithOneByteDataMap"),
0x039c1: (74, "ExternalOneByteStringMap"),
0x03a11: (98, "ShortExternalStringMap"),
0x03a61: (114, "ShortExternalStringWithOneByteDataMap"),
0x03ab1: (0, "InternalizedStringMap"),
0x03b01: (2, "ExternalInternalizedStringMap"),
0x03b51: (18, "ExternalInternalizedStringWithOneByteDataMap"),
0x03ba1: (10, "ExternalOneByteInternalizedStringMap"),
0x03bf1: (34, "ShortExternalInternalizedStringMap"),
0x03c41: (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
0x03c91: (42, "ShortExternalOneByteInternalizedStringMap"),
0x03ce1: (106, "ShortExternalOneByteStringMap"),
0x03d31: (140, "FixedUint8ArrayMap"),
0x03d81: (139, "FixedInt8ArrayMap"),
0x03dd1: (142, "FixedUint16ArrayMap"),
0x03e21: (141, "FixedInt16ArrayMap"),
0x03e71: (144, "FixedUint32ArrayMap"),
0x03ec1: (143, "FixedInt32ArrayMap"),
0x03f11: (145, "FixedFloat32ArrayMap"),
0x03f61: (146, "FixedFloat64ArrayMap"),
0x03fb1: (147, "FixedUint8ClampedArrayMap"),
0x04001: (169, "Tuple2Map"),
0x04051: (167, "ScriptMap"),
0x040a1: (160, "InterceptorInfoMap"),
0x040f1: (151, "AccessorInfoMap"),
0x04141: (150, "AccessCheckInfoMap"),
0x04191: (152, "AccessorPairMap"),
0x041e1: (153, "AliasedArgumentsEntryMap"),
0x04231: (154, "AllocationMementoMap"),
0x04281: (155, "AllocationSiteMap"),
0x042d1: (156, "AsyncGeneratorRequestMap"),
0x04321: (157, "ContextExtensionMap"),
0x04371: (158, "DebugInfoMap"),
0x043c1: (159, "FunctionTemplateInfoMap"),
0x04411: (161, "ModuleInfoEntryMap"),
0x04461: (162, "ModuleMap"),
0x044b1: (163, "ObjectTemplateInfoMap"),
0x04501: (164, "PromiseReactionJobInfoMap"),
0x04551: (165, "PromiseResolveThenableJobInfoMap"),
0x045a1: (166, "PrototypeInfoMap"),
0x045f1: (168, "StackFrameInfoMap"),
0x04641: (170, "Tuple3Map"),
}
# List of known V8 objects.