[heap] Use HashMap as scratchpad backing store
We use a scratchpad to remember visited allocation sites for post processing (making tenure decisions). The previous implementation used a rooted FixedArray with constant length (256) to remember all sites. Updating the scratchpad is a bottleneck in any parallel/concurrent implementation of newspace evacuation. The new implementation uses a HashMap with allocation sites as keys and temporary counts as values. During evacuation we collect a local hashmap of visited allocation sites. Upon merging the local hashmap back into a global one we update potential forward pointers of compacted allocation sites. The scavenger can directly enter its entries into the global hashmap. Note that the actual memento found count is still kept on the AllocationSite as it needs to survive scavenges and full GCs. BUG=chromium:524425 LOG=N R=hpayer@chromium.org Review URL: https://codereview.chromium.org/1535723002 Cr-Commit-Position: refs/heads/master@{#33233}
This commit is contained in:
mlippautz
Commit bot
parent
aacce20038
commit
55422bdd50
@ -507,24 +507,42 @@ AllocationMemento* Heap::FindAllocationMemento(HeapObject* object) {
|
||||
}
|
||||
|
||||
|
||||
void Heap::UpdateAllocationSiteFeedback(HeapObject* object,
|
||||
ScratchpadSlotMode mode) {
|
||||
Heap* heap = object->GetHeap();
|
||||
DCHECK(heap->InFromSpace(object));
|
||||
|
||||
void Heap::UpdateAllocationSite(HeapObject* object,
|
||||
HashMap* pretenuring_feedback) {
|
||||
DCHECK(InFromSpace(object));
|
||||
if (!FLAG_allocation_site_pretenuring ||
|
||||
!AllocationSite::CanTrack(object->map()->instance_type()))
|
||||
return;
|
||||
AllocationMemento* memento = FindAllocationMemento(object);
|
||||
if (memento == nullptr) return;
|
||||
|
||||
AllocationMemento* memento = heap->FindAllocationMemento(object);
|
||||
if (memento == NULL) return;
|
||||
AllocationSite* key = memento->GetAllocationSite();
|
||||
DCHECK(!key->IsZombie());
|
||||
|
||||
if (memento->GetAllocationSite()->IncrementMementoFoundCount()) {
|
||||
heap->AddAllocationSiteToScratchpad(memento->GetAllocationSite(), mode);
|
||||
if (pretenuring_feedback == global_pretenuring_feedback_) {
|
||||
// For inserting in the global pretenuring storage we need to first
|
||||
// increment the memento found count on the allocation site.
|
||||
if (key->IncrementMementoFoundCount()) {
|
||||
global_pretenuring_feedback_->LookupOrInsert(
|
||||
key, static_cast<uint32_t>(bit_cast<uintptr_t>(key)));
|
||||
}
|
||||
} else {
|
||||
// Any other pretenuring storage than the global one is used as a cache,
|
||||
// where the count is later on merge in the allocation site.
|
||||
HashMap::Entry* e = pretenuring_feedback->LookupOrInsert(
|
||||
key, static_cast<uint32_t>(bit_cast<uintptr_t>(key)));
|
||||
DCHECK(e != nullptr);
|
||||
(*bit_cast<intptr_t*>(&e->value))++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Heap::RemoveAllocationSitePretenuringFeedback(AllocationSite* site) {
|
||||
global_pretenuring_feedback_->Remove(
|
||||
site, static_cast<uint32_t>(bit_cast<uintptr_t>(site)));
|
||||
}
|
||||
|
||||
|
||||
bool Heap::CollectGarbage(AllocationSpace space, const char* gc_reason,
|
||||
const v8::GCCallbackFlags callbackFlags) {
|
||||
const char* collector_reason = NULL;
|
||||
|
||||
218
src/heap/heap.cc
218
src/heap/heap.cc
@ -150,7 +150,7 @@ Heap::Heap()
|
||||
old_generation_allocation_counter_(0),
|
||||
old_generation_size_at_last_gc_(0),
|
||||
gcs_since_last_deopt_(0),
|
||||
allocation_sites_scratchpad_length_(0),
|
||||
global_pretenuring_feedback_(nullptr),
|
||||
ring_buffer_full_(false),
|
||||
ring_buffer_end_(0),
|
||||
promotion_queue_(this),
|
||||
@ -508,7 +508,51 @@ void Heap::RepairFreeListsAfterDeserialization() {
|
||||
}
|
||||
|
||||
|
||||
bool Heap::ProcessPretenuringFeedback() {
|
||||
void Heap::MergeAllocationSitePretenuringFeedback(
|
||||
const HashMap& local_pretenuring_feedback) {
|
||||
AllocationSite* site = nullptr;
|
||||
for (HashMap::Entry* local_entry = local_pretenuring_feedback.Start();
|
||||
local_entry != nullptr;
|
||||
local_entry = local_pretenuring_feedback.Next(local_entry)) {
|
||||
site = reinterpret_cast<AllocationSite*>(local_entry->key);
|
||||
MapWord map_word = site->map_word();
|
||||
if (map_word.IsForwardingAddress()) {
|
||||
site = AllocationSite::cast(map_word.ToForwardingAddress());
|
||||
}
|
||||
DCHECK(site->IsAllocationSite());
|
||||
int value =
|
||||
static_cast<int>(reinterpret_cast<intptr_t>(local_entry->value));
|
||||
DCHECK_GT(value, 0);
|
||||
|
||||
{
|
||||
// TODO(mlippautz): For parallel processing we need synchronization here.
|
||||
if (site->IncrementMementoFoundCount(value)) {
|
||||
global_pretenuring_feedback_->LookupOrInsert(
|
||||
site, static_cast<uint32_t>(bit_cast<uintptr_t>(site)));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class Heap::PretenuringScope {
|
||||
public:
|
||||
explicit PretenuringScope(Heap* heap) : heap_(heap) {
|
||||
heap_->global_pretenuring_feedback_ =
|
||||
new HashMap(HashMap::PointersMatch, kInitialFeedbackCapacity);
|
||||
}
|
||||
|
||||
~PretenuringScope() {
|
||||
delete heap_->global_pretenuring_feedback_;
|
||||
heap_->global_pretenuring_feedback_ = nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
Heap* heap_;
|
||||
};
|
||||
|
||||
|
||||
void Heap::ProcessPretenuringFeedback() {
|
||||
bool trigger_deoptimization = false;
|
||||
if (FLAG_allocation_site_pretenuring) {
|
||||
int tenure_decisions = 0;
|
||||
@ -517,48 +561,43 @@ bool Heap::ProcessPretenuringFeedback() {
|
||||
int allocation_sites = 0;
|
||||
int active_allocation_sites = 0;
|
||||
|
||||
// If the scratchpad overflowed, we have to iterate over the allocation
|
||||
// sites list.
|
||||
// TODO(hpayer): We iterate over the whole list of allocation sites when
|
||||
// we grew to the maximum semi-space size to deopt maybe tenured
|
||||
// allocation sites. We could hold the maybe tenured allocation sites
|
||||
// in a seperate data structure if this is a performance problem.
|
||||
bool deopt_maybe_tenured = DeoptMaybeTenuredAllocationSites();
|
||||
bool use_scratchpad =
|
||||
allocation_sites_scratchpad_length_ < kAllocationSiteScratchpadSize &&
|
||||
!deopt_maybe_tenured;
|
||||
AllocationSite* site = nullptr;
|
||||
|
||||
int i = 0;
|
||||
Object* list_element = allocation_sites_list();
|
||||
// Step 1: Digest feedback for recorded allocation sites.
|
||||
bool maximum_size_scavenge = MaximumSizeScavenge();
|
||||
while (use_scratchpad ? i < allocation_sites_scratchpad_length_
|
||||
: list_element->IsAllocationSite()) {
|
||||
AllocationSite* site =
|
||||
use_scratchpad
|
||||
? AllocationSite::cast(allocation_sites_scratchpad()->get(i))
|
||||
: AllocationSite::cast(list_element);
|
||||
allocation_mementos_found += site->memento_found_count();
|
||||
if (site->memento_found_count() > 0) {
|
||||
active_allocation_sites++;
|
||||
if (site->DigestPretenuringFeedback(maximum_size_scavenge)) {
|
||||
trigger_deoptimization = true;
|
||||
}
|
||||
if (site->GetPretenureMode() == TENURED) {
|
||||
tenure_decisions++;
|
||||
} else {
|
||||
dont_tenure_decisions++;
|
||||
}
|
||||
allocation_sites++;
|
||||
}
|
||||
|
||||
if (deopt_maybe_tenured && site->IsMaybeTenure()) {
|
||||
site->set_deopt_dependent_code(true);
|
||||
for (HashMap::Entry* e = global_pretenuring_feedback_->Start();
|
||||
e != nullptr; e = global_pretenuring_feedback_->Next(e)) {
|
||||
site = reinterpret_cast<AllocationSite*>(e->key);
|
||||
int found_count = site->memento_found_count();
|
||||
// The fact that we have an entry in the storage means that we've found
|
||||
// the site at least once.
|
||||
DCHECK_GT(found_count, 0);
|
||||
DCHECK(site->IsAllocationSite());
|
||||
allocation_sites++;
|
||||
active_allocation_sites++;
|
||||
allocation_mementos_found += found_count;
|
||||
if (site->DigestPretenuringFeedback(maximum_size_scavenge)) {
|
||||
trigger_deoptimization = true;
|
||||
}
|
||||
|
||||
if (use_scratchpad) {
|
||||
i++;
|
||||
if (site->GetPretenureMode() == TENURED) {
|
||||
tenure_decisions++;
|
||||
} else {
|
||||
dont_tenure_decisions++;
|
||||
}
|
||||
}
|
||||
|
||||
// Step 2: Deopt maybe tenured allocation sites if necessary.
|
||||
bool deopt_maybe_tenured = DeoptMaybeTenuredAllocationSites();
|
||||
if (deopt_maybe_tenured) {
|
||||
Object* list_element = allocation_sites_list();
|
||||
while (list_element->IsAllocationSite()) {
|
||||
site = AllocationSite::cast(list_element);
|
||||
DCHECK(site->IsAllocationSite());
|
||||
allocation_sites++;
|
||||
if (site->IsMaybeTenure()) {
|
||||
site->set_deopt_dependent_code(true);
|
||||
trigger_deoptimization = true;
|
||||
}
|
||||
list_element = site->weak_next();
|
||||
}
|
||||
}
|
||||
@ -567,28 +606,24 @@ bool Heap::ProcessPretenuringFeedback() {
|
||||
isolate_->stack_guard()->RequestDeoptMarkedAllocationSites();
|
||||
}
|
||||
|
||||
FlushAllocationSitesScratchpad();
|
||||
|
||||
if (FLAG_trace_pretenuring_statistics &&
|
||||
(allocation_mementos_found > 0 || tenure_decisions > 0 ||
|
||||
dont_tenure_decisions > 0)) {
|
||||
PrintF(
|
||||
"GC: (mode, #visited allocation sites, #active allocation sites, "
|
||||
"#mementos, #tenure decisions, #donttenure decisions) "
|
||||
"(%s, %d, %d, %d, %d, %d)\n",
|
||||
use_scratchpad ? "use scratchpad" : "use list", allocation_sites,
|
||||
active_allocation_sites, allocation_mementos_found, tenure_decisions,
|
||||
dont_tenure_decisions);
|
||||
PrintIsolate(isolate(),
|
||||
"pretenuring: deopt_maybe_tenured=%d visited_sites=%d "
|
||||
"active_sites=%d "
|
||||
"mementos=%d tenured=%d not_tenured=%d\n",
|
||||
deopt_maybe_tenured ? 1 : 0, allocation_sites,
|
||||
active_allocation_sites, allocation_mementos_found,
|
||||
tenure_decisions, dont_tenure_decisions);
|
||||
}
|
||||
}
|
||||
return trigger_deoptimization;
|
||||
}
|
||||
|
||||
|
||||
void Heap::DeoptMarkedAllocationSites() {
|
||||
// TODO(hpayer): If iterating over the allocation sites list becomes a
|
||||
// performance issue, use a cache heap data structure instead (similar to the
|
||||
// allocation sites scratchpad).
|
||||
// performance issue, use a cache data structure in heap instead.
|
||||
Object* list_element = allocation_sites_list();
|
||||
while (list_element->IsAllocationSite()) {
|
||||
AllocationSite* site = AllocationSite::cast(list_element);
|
||||
@ -1262,22 +1297,27 @@ bool Heap::PerformGarbageCollection(
|
||||
incremental_marking()->NotifyOfHighPromotionRate();
|
||||
}
|
||||
|
||||
if (collector == MARK_COMPACTOR) {
|
||||
UpdateOldGenerationAllocationCounter();
|
||||
// Perform mark-sweep with optional compaction.
|
||||
MarkCompact();
|
||||
old_gen_exhausted_ = false;
|
||||
old_generation_size_configured_ = true;
|
||||
// This should be updated before PostGarbageCollectionProcessing, which can
|
||||
// cause another GC. Take into account the objects promoted during GC.
|
||||
old_generation_allocation_counter_ +=
|
||||
static_cast<size_t>(promoted_objects_size_);
|
||||
old_generation_size_at_last_gc_ = PromotedSpaceSizeOfObjects();
|
||||
} else {
|
||||
Scavenge();
|
||||
{
|
||||
Heap::PretenuringScope pretenuring_scope(this);
|
||||
|
||||
if (collector == MARK_COMPACTOR) {
|
||||
UpdateOldGenerationAllocationCounter();
|
||||
// Perform mark-sweep with optional compaction.
|
||||
MarkCompact();
|
||||
old_gen_exhausted_ = false;
|
||||
old_generation_size_configured_ = true;
|
||||
// This should be updated before PostGarbageCollectionProcessing, which
|
||||
// can cause another GC. Take into account the objects promoted during GC.
|
||||
old_generation_allocation_counter_ +=
|
||||
static_cast<size_t>(promoted_objects_size_);
|
||||
old_generation_size_at_last_gc_ = PromotedSpaceSizeOfObjects();
|
||||
} else {
|
||||
Scavenge();
|
||||
}
|
||||
|
||||
ProcessPretenuringFeedback();
|
||||
}
|
||||
|
||||
ProcessPretenuringFeedback();
|
||||
UpdateSurvivalStatistics(start_new_space_size);
|
||||
ConfigureInitialOldGenerationSize();
|
||||
|
||||
@ -1830,6 +1870,7 @@ void Heap::ResetAllAllocationSitesDependentCode(PretenureFlag flag) {
|
||||
casted->ResetPretenureDecision();
|
||||
casted->set_deopt_dependent_code(true);
|
||||
marked = true;
|
||||
RemoveAllocationSitePretenuringFeedback(casted);
|
||||
}
|
||||
cur = casted->weak_next();
|
||||
}
|
||||
@ -2835,10 +2876,6 @@ void Heap::CreateInitialObjects() {
|
||||
*interpreter::Interpreter::CreateUninitializedInterpreterTable(
|
||||
isolate()));
|
||||
|
||||
set_allocation_sites_scratchpad(
|
||||
*factory->NewFixedArray(kAllocationSiteScratchpadSize, TENURED));
|
||||
InitializeAllocationSitesScratchpad();
|
||||
|
||||
// Initialize keyed lookup cache.
|
||||
isolate_->keyed_lookup_cache()->Clear();
|
||||
|
||||
@ -2867,7 +2904,6 @@ bool Heap::RootCanBeWrittenAfterInitialization(Heap::RootListIndex root_index) {
|
||||
case kSymbolRegistryRootIndex:
|
||||
case kScriptListRootIndex:
|
||||
case kMaterializedObjectsRootIndex:
|
||||
case kAllocationSitesScratchpadRootIndex:
|
||||
case kMicrotaskQueueRootIndex:
|
||||
case kDetachedContextsRootIndex:
|
||||
case kWeakObjectToCodeTableRootIndex:
|
||||
@ -2916,48 +2952,6 @@ void Heap::FlushNumberStringCache() {
|
||||
}
|
||||
|
||||
|
||||
void Heap::FlushAllocationSitesScratchpad() {
|
||||
for (int i = 0; i < allocation_sites_scratchpad_length_; i++) {
|
||||
allocation_sites_scratchpad()->set_undefined(i);
|
||||
}
|
||||
allocation_sites_scratchpad_length_ = 0;
|
||||
}
|
||||
|
||||
|
||||
void Heap::InitializeAllocationSitesScratchpad() {
|
||||
DCHECK(allocation_sites_scratchpad()->length() ==
|
||||
kAllocationSiteScratchpadSize);
|
||||
for (int i = 0; i < kAllocationSiteScratchpadSize; i++) {
|
||||
allocation_sites_scratchpad()->set_undefined(i);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Heap::AddAllocationSiteToScratchpad(AllocationSite* site,
|
||||
ScratchpadSlotMode mode) {
|
||||
if (allocation_sites_scratchpad_length_ < kAllocationSiteScratchpadSize) {
|
||||
// We cannot use the normal write-barrier because slots need to be
|
||||
// recorded with non-incremental marking as well. We have to explicitly
|
||||
// record the slot to take evacuation candidates into account.
|
||||
allocation_sites_scratchpad()->set(allocation_sites_scratchpad_length_,
|
||||
site, SKIP_WRITE_BARRIER);
|
||||
Object** slot = allocation_sites_scratchpad()->RawFieldOfElementAt(
|
||||
allocation_sites_scratchpad_length_);
|
||||
|
||||
if (mode == RECORD_SCRATCHPAD_SLOT) {
|
||||
// We need to allow slots buffer overflow here since the evacuation
|
||||
// candidates are not part of the global list of old space pages and
|
||||
// releasing an evacuation candidate due to a slots buffer overflow
|
||||
// results in lost pages.
|
||||
mark_compact_collector()->ForceRecordSlot(allocation_sites_scratchpad(),
|
||||
slot, *slot);
|
||||
}
|
||||
allocation_sites_scratchpad_length_++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
Map* Heap::MapForFixedTypedArray(ExternalArrayType array_type) {
|
||||
return Map::cast(roots_[RootIndexForFixedTypedArray(array_type)]);
|
||||
}
|
||||
|
||||
@ -176,7 +176,6 @@ namespace internal {
|
||||
V(SeededNumberDictionary, empty_slow_element_dictionary, \
|
||||
EmptySlowElementDictionary) \
|
||||
V(FixedArray, materialized_objects, MaterializedObjects) \
|
||||
V(FixedArray, allocation_sites_scratchpad, AllocationSitesScratchpad) \
|
||||
V(FixedArray, microtask_queue, MicrotaskQueue) \
|
||||
V(TypeFeedbackVector, dummy_vector, DummyVector) \
|
||||
V(FixedArray, cleared_optimized_code_map, ClearedOptimizedCodeMap) \
|
||||
@ -636,7 +635,7 @@ class Heap {
|
||||
// - or mutator code (CONCURRENT_TO_SWEEPER).
|
||||
enum InvocationMode { SEQUENTIAL_TO_SWEEPER, CONCURRENT_TO_SWEEPER };
|
||||
|
||||
enum ScratchpadSlotMode { IGNORE_SCRATCHPAD_SLOT, RECORD_SCRATCHPAD_SLOT };
|
||||
enum PretenuringFeedbackInsertionMode { kCached, kGlobal };
|
||||
|
||||
enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT };
|
||||
|
||||
@ -762,12 +761,6 @@ class Heap {
|
||||
// Checks whether the space is valid.
|
||||
static bool IsValidAllocationSpace(AllocationSpace space);
|
||||
|
||||
// An object may have an AllocationSite associated with it through a trailing
|
||||
// AllocationMemento. Its feedback should be updated when objects are found
|
||||
// in the heap.
|
||||
static inline void UpdateAllocationSiteFeedback(HeapObject* object,
|
||||
ScratchpadSlotMode mode);
|
||||
|
||||
// Generated code can embed direct references to non-writable roots if
|
||||
// they are in new space.
|
||||
static bool RootCanBeWrittenAfterInitialization(RootListIndex root_index);
|
||||
@ -1544,6 +1537,27 @@ class Heap {
|
||||
return array_buffer_tracker_;
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// Allocation site tracking. =================================================
|
||||
// ===========================================================================
|
||||
|
||||
// Updates the AllocationSite of a given {object}. If the global prenuring
|
||||
// storage is passed as {pretenuring_feedback} the memento found count on
|
||||
// the corresponding allocation site is immediately updated and an entry
|
||||
// in the hash map is created. Otherwise the entry (including a the count
|
||||
// value) is cached on the local pretenuring feedback.
|
||||
inline void UpdateAllocationSite(HeapObject* object,
|
||||
HashMap* pretenuring_feedback);
|
||||
|
||||
// Removes an entry from the global pretenuring storage.
|
||||
inline void RemoveAllocationSitePretenuringFeedback(AllocationSite* site);
|
||||
|
||||
// Merges local pretenuring feedback into the global one. Note that this
|
||||
// method needs to be called after evacuation, as allocation sites may be
|
||||
// evacuated and this method resolves forward pointers accordingly.
|
||||
void MergeAllocationSitePretenuringFeedback(
|
||||
const HashMap& local_pretenuring_feedback);
|
||||
|
||||
// =============================================================================
|
||||
|
||||
#ifdef VERIFY_HEAP
|
||||
@ -1567,6 +1581,7 @@ class Heap {
|
||||
#endif
|
||||
|
||||
private:
|
||||
class PretenuringScope;
|
||||
class UnmapFreeMemoryTask;
|
||||
|
||||
// External strings table is a place where all external strings are
|
||||
@ -1661,7 +1676,7 @@ class Heap {
|
||||
static const int kMaxMarkCompactsInIdleRound = 7;
|
||||
static const int kIdleScavengeThreshold = 5;
|
||||
|
||||
static const int kAllocationSiteScratchpadSize = 256;
|
||||
static const int kInitialFeedbackCapacity = 256;
|
||||
|
||||
Heap();
|
||||
|
||||
@ -1703,12 +1718,6 @@ class Heap {
|
||||
|
||||
void PreprocessStackTraces();
|
||||
|
||||
// Pretenuring decisions are made based on feedback collected during new
|
||||
// space evacuation. Note that between feedback collection and calling this
|
||||
// method object in old space must not move.
|
||||
// Right now we only process pretenuring feedback in high promotion mode.
|
||||
bool ProcessPretenuringFeedback();
|
||||
|
||||
// Checks whether a global GC is necessary
|
||||
GarbageCollector SelectGarbageCollector(AllocationSpace space,
|
||||
const char** reason);
|
||||
@ -1788,16 +1797,6 @@ class Heap {
|
||||
// Flush the number to string cache.
|
||||
void FlushNumberStringCache();
|
||||
|
||||
// Sets used allocation sites entries to undefined.
|
||||
void FlushAllocationSitesScratchpad();
|
||||
|
||||
// Initializes the allocation sites scratchpad with undefined values.
|
||||
void InitializeAllocationSitesScratchpad();
|
||||
|
||||
// Adds an allocation site to the scratchpad if there is space left.
|
||||
void AddAllocationSiteToScratchpad(AllocationSite* site,
|
||||
ScratchpadSlotMode mode);
|
||||
|
||||
// TODO(hpayer): Allocation site pretenuring may make this method obsolete.
|
||||
// Re-visit incremental marking heuristics.
|
||||
bool IsHighSurvivalRate() { return high_survival_rate_period_length_ > 0; }
|
||||
@ -1848,6 +1847,15 @@ class Heap {
|
||||
// memory reduction
|
||||
HistogramTimer* GCTypeTimer(GarbageCollector collector);
|
||||
|
||||
// ===========================================================================
|
||||
// Pretenuring. ==============================================================
|
||||
// ===========================================================================
|
||||
|
||||
// Pretenuring decisions are made based on feedback collected during new space
|
||||
// evacuation. Note that between feedback collection and calling this method
|
||||
// object in old space must not move.
|
||||
void ProcessPretenuringFeedback();
|
||||
|
||||
// ===========================================================================
|
||||
// Actual GC. ================================================================
|
||||
// ===========================================================================
|
||||
@ -2143,6 +2151,8 @@ class Heap {
|
||||
|
||||
MUST_USE_RESULT AllocationResult InternalizeString(String* str);
|
||||
|
||||
// ===========================================================================
|
||||
|
||||
void set_force_oom(bool value) { force_oom_ = value; }
|
||||
|
||||
// The amount of external memory registered through the API kept alive
|
||||
@ -2352,7 +2362,12 @@ class Heap {
|
||||
// deoptimization triggered by garbage collection.
|
||||
int gcs_since_last_deopt_;
|
||||
|
||||
int allocation_sites_scratchpad_length_;
|
||||
// The feedback storage is used to store allocation sites (keys) and how often
|
||||
// they have been visited (values) by finding a memento behind an object. The
|
||||
// storage is only alive temporary during a GC. The invariant is that all
|
||||
// pointers in this map are already fixed, i.e., they do not point to
|
||||
// forwarding pointers.
|
||||
HashMap* global_pretenuring_feedback_;
|
||||
|
||||
char trace_ring_buffer_[kTraceRingBufferSize];
|
||||
// If it's not full then the data is from 0 to ring_buffer_end_. If it's
|
||||
|
||||
@ -1581,15 +1581,17 @@ class MarkCompactCollector::EvacuateNewSpaceVisitor final
|
||||
static const intptr_t kMaxLabObjectSize = 256;
|
||||
|
||||
explicit EvacuateNewSpaceVisitor(Heap* heap,
|
||||
SlotsBuffer** evacuation_slots_buffer)
|
||||
SlotsBuffer** evacuation_slots_buffer,
|
||||
HashMap* local_pretenuring_feedback)
|
||||
: EvacuateVisitorBase(heap, evacuation_slots_buffer),
|
||||
buffer_(LocalAllocationBuffer::InvalidBuffer()),
|
||||
space_to_allocate_(NEW_SPACE),
|
||||
promoted_size_(0),
|
||||
semispace_copied_size_(0) {}
|
||||
semispace_copied_size_(0),
|
||||
local_pretenuring_feedback_(local_pretenuring_feedback) {}
|
||||
|
||||
bool Visit(HeapObject* object) override {
|
||||
Heap::UpdateAllocationSiteFeedback(object, Heap::RECORD_SCRATCHPAD_SLOT);
|
||||
heap_->UpdateAllocationSite(object, local_pretenuring_feedback_);
|
||||
int size = object->Size();
|
||||
HeapObject* target_object = nullptr;
|
||||
if (heap_->ShouldBePromoted(object->address(), size) &&
|
||||
@ -1716,6 +1718,7 @@ class MarkCompactCollector::EvacuateNewSpaceVisitor final
|
||||
AllocationSpace space_to_allocate_;
|
||||
intptr_t promoted_size_;
|
||||
intptr_t semispace_copied_size_;
|
||||
HashMap* local_pretenuring_feedback_;
|
||||
};
|
||||
|
||||
|
||||
@ -3056,7 +3059,7 @@ void MarkCompactCollector::VerifyIsSlotInLiveObject(Address slot,
|
||||
}
|
||||
|
||||
|
||||
void MarkCompactCollector::EvacuateNewSpace() {
|
||||
void MarkCompactCollector::EvacuateNewSpacePrologue() {
|
||||
// There are soft limits in the allocation code, designed trigger a mark
|
||||
// sweep collection by failing allocations. But since we are already in
|
||||
// a mark-sweep allocation, there is no sense in trying to trigger one.
|
||||
@ -3073,14 +3076,26 @@ void MarkCompactCollector::EvacuateNewSpace() {
|
||||
new_space->Flip();
|
||||
new_space->ResetAllocationInfo();
|
||||
|
||||
newspace_evacuation_candidates_.Clear();
|
||||
NewSpacePageIterator it(from_bottom, from_top);
|
||||
while (it.has_next()) {
|
||||
newspace_evacuation_candidates_.Add(it.next());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
HashMap* MarkCompactCollector::EvacuateNewSpaceInParallel() {
|
||||
HashMap* local_pretenuring_feedback = new HashMap(
|
||||
HashMap::PointersMatch, kInitialLocalPretenuringFeedbackCapacity);
|
||||
EvacuateNewSpaceVisitor new_space_visitor(heap(), &migration_slots_buffer_,
|
||||
local_pretenuring_feedback);
|
||||
// First pass: traverse all objects in inactive semispace, remove marks,
|
||||
// migrate live objects and write forwarding addresses. This stage puts
|
||||
// new entries in the store buffer and may cause some pages to be marked
|
||||
// scan-on-scavenge.
|
||||
NewSpacePageIterator it(from_bottom, from_top);
|
||||
EvacuateNewSpaceVisitor new_space_visitor(heap(), &migration_slots_buffer_);
|
||||
while (it.has_next()) {
|
||||
NewSpacePage* p = it.next();
|
||||
for (int i = 0; i < newspace_evacuation_candidates_.length(); i++) {
|
||||
NewSpacePage* p =
|
||||
reinterpret_cast<NewSpacePage*>(newspace_evacuation_candidates_[i]);
|
||||
bool ok = VisitLiveObjects(p, &new_space_visitor, kClearMarkbits);
|
||||
USE(ok);
|
||||
DCHECK(ok);
|
||||
@ -3092,7 +3107,7 @@ void MarkCompactCollector::EvacuateNewSpace() {
|
||||
heap_->IncrementYoungSurvivorsCounter(
|
||||
static_cast<int>(new_space_visitor.promoted_size()) +
|
||||
static_cast<int>(new_space_visitor.semispace_copied_size()));
|
||||
new_space->set_age_mark(new_space->top());
|
||||
return local_pretenuring_feedback;
|
||||
}
|
||||
|
||||
|
||||
@ -3557,11 +3572,14 @@ void MarkCompactCollector::EvacuateNewSpaceAndCandidates() {
|
||||
GCTracer::Scope gc_scope(heap()->tracer(), GCTracer::Scope::MC_EVACUATE);
|
||||
Heap::RelocationLock relocation_lock(heap());
|
||||
|
||||
HashMap* local_pretenuring_feedback = nullptr;
|
||||
{
|
||||
GCTracer::Scope gc_scope(heap()->tracer(),
|
||||
GCTracer::Scope::MC_EVACUATE_NEW_SPACE);
|
||||
EvacuationScope evacuation_scope(this);
|
||||
EvacuateNewSpace();
|
||||
EvacuateNewSpacePrologue();
|
||||
local_pretenuring_feedback = EvacuateNewSpaceInParallel();
|
||||
heap_->new_space()->set_age_mark(heap_->new_space()->top());
|
||||
}
|
||||
|
||||
{
|
||||
@ -3571,6 +3589,11 @@ void MarkCompactCollector::EvacuateNewSpaceAndCandidates() {
|
||||
EvacuatePagesInParallel();
|
||||
}
|
||||
|
||||
{
|
||||
heap_->MergeAllocationSitePretenuringFeedback(*local_pretenuring_feedback);
|
||||
delete local_pretenuring_feedback;
|
||||
}
|
||||
|
||||
UpdatePointersAfterEvacuation();
|
||||
|
||||
{
|
||||
|
||||
@ -511,6 +511,8 @@ class MarkCompactCollector {
|
||||
class HeapObjectVisitor;
|
||||
class SweeperTask;
|
||||
|
||||
static const int kInitialLocalPretenuringFeedbackCapacity = 256;
|
||||
|
||||
explicit MarkCompactCollector(Heap* heap);
|
||||
|
||||
bool WillBeDeoptimized(Code* code);
|
||||
@ -696,7 +698,10 @@ class MarkCompactCollector {
|
||||
// regions to each space's free list.
|
||||
void SweepSpaces();
|
||||
|
||||
void EvacuateNewSpace();
|
||||
void EvacuateNewSpacePrologue();
|
||||
|
||||
// Returns local pretenuring feedback.
|
||||
HashMap* EvacuateNewSpaceInParallel();
|
||||
|
||||
void AddEvacuationSlotsBufferSynchronized(
|
||||
SlotsBuffer* evacuation_slots_buffer);
|
||||
@ -772,6 +777,8 @@ class MarkCompactCollector {
|
||||
|
||||
List<Page*> evacuation_candidates_;
|
||||
|
||||
List<MemoryChunk*> newspace_evacuation_candidates_;
|
||||
|
||||
// The evacuation_slots_buffers_ are used by the compaction threads.
|
||||
// When a compaction task finishes, it uses
|
||||
// AddEvacuationSlotsbufferSynchronized to adds its slots buffer to the
|
||||
|
||||
@ -28,7 +28,8 @@ void Scavenger::ScavengeObject(HeapObject** p, HeapObject* object) {
|
||||
return;
|
||||
}
|
||||
|
||||
Heap::UpdateAllocationSiteFeedback(object, Heap::IGNORE_SCRATCHPAD_SLOT);
|
||||
object->GetHeap()->UpdateAllocationSite(
|
||||
object, object->GetHeap()->global_pretenuring_feedback_);
|
||||
|
||||
// AllocationMementos are unrooted and shouldn't survive a scavenge
|
||||
DCHECK(object->map() != object->GetHeap()->allocation_memento_map());
|
||||
|
||||
@ -3056,7 +3056,6 @@ HeapObject* LargeObjectIterator::Next() {
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// LargeObjectSpace
|
||||
static bool ComparePointers(void* key1, void* key2) { return key1 == key2; }
|
||||
|
||||
|
||||
LargeObjectSpace::LargeObjectSpace(Heap* heap, AllocationSpace id)
|
||||
@ -3065,7 +3064,7 @@ LargeObjectSpace::LargeObjectSpace(Heap* heap, AllocationSpace id)
|
||||
size_(0),
|
||||
page_count_(0),
|
||||
objects_size_(0),
|
||||
chunk_map_(ComparePointers, 1024) {}
|
||||
chunk_map_(HashMap::PointersMatch, 1024) {}
|
||||
|
||||
|
||||
LargeObjectSpace::~LargeObjectSpace() {}
|
||||
|
||||
@ -1773,12 +1773,12 @@ void AllocationSite::set_memento_create_count(int count) {
|
||||
}
|
||||
|
||||
|
||||
inline bool AllocationSite::IncrementMementoFoundCount() {
|
||||
bool AllocationSite::IncrementMementoFoundCount(int increment) {
|
||||
if (IsZombie()) return false;
|
||||
|
||||
int value = memento_found_count();
|
||||
set_memento_found_count(value + 1);
|
||||
return memento_found_count() == kPretenureMinimumCreated;
|
||||
set_memento_found_count(value + increment);
|
||||
return memento_found_count() >= kPretenureMinimumCreated;
|
||||
}
|
||||
|
||||
|
||||
@ -1832,11 +1832,12 @@ inline bool AllocationSite::DigestPretenuringFeedback(
|
||||
}
|
||||
|
||||
if (FLAG_trace_pretenuring_statistics) {
|
||||
PrintF(
|
||||
"AllocationSite(%p): (created, found, ratio) (%d, %d, %f) %s => %s\n",
|
||||
static_cast<void*>(this), create_count, found_count, ratio,
|
||||
PretenureDecisionName(current_decision),
|
||||
PretenureDecisionName(pretenure_decision()));
|
||||
PrintIsolate(GetIsolate(),
|
||||
"pretenuring: AllocationSite(%p): (created, found, ratio) "
|
||||
"(%d, %d, %f) %s => %s\n",
|
||||
this, create_count, found_count, ratio,
|
||||
PretenureDecisionName(current_decision),
|
||||
PretenureDecisionName(pretenure_decision()));
|
||||
}
|
||||
|
||||
// Clear feedback calculation fields until the next gc.
|
||||
|
||||
@ -8149,7 +8149,7 @@ class AllocationSite: public Struct {
|
||||
|
||||
// Increments the mementos found counter and returns true when the first
|
||||
// memento was found for a given allocation site.
|
||||
inline bool IncrementMementoFoundCount();
|
||||
inline bool IncrementMementoFoundCount(int increment = 1);
|
||||
|
||||
inline void IncrementMementoCreateCount();
|
||||
|
||||
|
||||
@ -51,258 +51,247 @@ INSTANCE_TYPES = {
|
||||
22: "SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE",
|
||||
26: "SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE",
|
||||
128: "SYMBOL_TYPE",
|
||||
134: "FLOAT32X4_TYPE",
|
||||
129: "MAP_TYPE",
|
||||
130: "CODE_TYPE",
|
||||
130: "SIMD128_VALUE_TYPE",
|
||||
132: "MAP_TYPE",
|
||||
133: "CODE_TYPE",
|
||||
131: "ODDBALL_TYPE",
|
||||
182: "CELL_TYPE",
|
||||
184: "PROPERTY_CELL_TYPE",
|
||||
132: "HEAP_NUMBER_TYPE",
|
||||
133: "MUTABLE_HEAP_NUMBER_TYPE",
|
||||
173: "CELL_TYPE",
|
||||
176: "PROPERTY_CELL_TYPE",
|
||||
129: "HEAP_NUMBER_TYPE",
|
||||
134: "MUTABLE_HEAP_NUMBER_TYPE",
|
||||
135: "FOREIGN_TYPE",
|
||||
136: "BYTE_ARRAY_TYPE",
|
||||
137: "BYTECODE_ARRAY_TYPE",
|
||||
138: "FREE_SPACE_TYPE",
|
||||
139: "EXTERNAL_INT8_ARRAY_TYPE",
|
||||
140: "EXTERNAL_UINT8_ARRAY_TYPE",
|
||||
141: "EXTERNAL_INT16_ARRAY_TYPE",
|
||||
142: "EXTERNAL_UINT16_ARRAY_TYPE",
|
||||
143: "EXTERNAL_INT32_ARRAY_TYPE",
|
||||
144: "EXTERNAL_UINT32_ARRAY_TYPE",
|
||||
145: "EXTERNAL_FLOAT32_ARRAY_TYPE",
|
||||
146: "EXTERNAL_FLOAT64_ARRAY_TYPE",
|
||||
147: "EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE",
|
||||
148: "FIXED_INT8_ARRAY_TYPE",
|
||||
149: "FIXED_UINT8_ARRAY_TYPE",
|
||||
150: "FIXED_INT16_ARRAY_TYPE",
|
||||
151: "FIXED_UINT16_ARRAY_TYPE",
|
||||
152: "FIXED_INT32_ARRAY_TYPE",
|
||||
153: "FIXED_UINT32_ARRAY_TYPE",
|
||||
154: "FIXED_FLOAT32_ARRAY_TYPE",
|
||||
155: "FIXED_FLOAT64_ARRAY_TYPE",
|
||||
156: "FIXED_UINT8_CLAMPED_ARRAY_TYPE",
|
||||
158: "FILLER_TYPE",
|
||||
159: "DECLARED_ACCESSOR_DESCRIPTOR_TYPE",
|
||||
160: "DECLARED_ACCESSOR_INFO_TYPE",
|
||||
161: "EXECUTABLE_ACCESSOR_INFO_TYPE",
|
||||
162: "ACCESSOR_PAIR_TYPE",
|
||||
163: "ACCESS_CHECK_INFO_TYPE",
|
||||
164: "INTERCEPTOR_INFO_TYPE",
|
||||
165: "CALL_HANDLER_INFO_TYPE",
|
||||
166: "FUNCTION_TEMPLATE_INFO_TYPE",
|
||||
167: "OBJECT_TEMPLATE_INFO_TYPE",
|
||||
168: "SIGNATURE_INFO_TYPE",
|
||||
169: "TYPE_SWITCH_INFO_TYPE",
|
||||
171: "ALLOCATION_MEMENTO_TYPE",
|
||||
170: "ALLOCATION_SITE_TYPE",
|
||||
172: "SCRIPT_TYPE",
|
||||
173: "CODE_CACHE_TYPE",
|
||||
174: "POLYMORPHIC_CODE_CACHE_TYPE",
|
||||
175: "TYPE_FEEDBACK_INFO_TYPE",
|
||||
176: "ALIASED_ARGUMENTS_ENTRY_TYPE",
|
||||
177: "BOX_TYPE",
|
||||
185: "PROTOTYPE_INFO_TYPE",
|
||||
180: "FIXED_ARRAY_TYPE",
|
||||
157: "FIXED_DOUBLE_ARRAY_TYPE",
|
||||
181: "SHARED_FUNCTION_INFO_TYPE",
|
||||
183: "WEAK_CELL_TYPE",
|
||||
189: "JS_MESSAGE_OBJECT_TYPE",
|
||||
188: "JS_VALUE_TYPE",
|
||||
190: "JS_DATE_TYPE",
|
||||
191: "JS_OBJECT_TYPE",
|
||||
192: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
|
||||
193: "JS_GENERATOR_OBJECT_TYPE",
|
||||
194: "JS_MODULE_TYPE",
|
||||
195: "JS_GLOBAL_OBJECT_TYPE",
|
||||
196: "JS_BUILTINS_OBJECT_TYPE",
|
||||
197: "JS_GLOBAL_PROXY_TYPE",
|
||||
198: "JS_ARRAY_TYPE",
|
||||
199: "JS_ARRAY_BUFFER_TYPE",
|
||||
200: "JS_TYPED_ARRAY_TYPE",
|
||||
201: "JS_DATA_VIEW_TYPE",
|
||||
187: "JS_PROXY_TYPE",
|
||||
202: "JS_SET_TYPE",
|
||||
203: "JS_MAP_TYPE",
|
||||
204: "JS_SET_ITERATOR_TYPE",
|
||||
205: "JS_MAP_ITERATOR_TYPE",
|
||||
206: "JS_WEAK_MAP_TYPE",
|
||||
207: "JS_WEAK_SET_TYPE",
|
||||
208: "JS_REGEXP_TYPE",
|
||||
209: "JS_FUNCTION_TYPE",
|
||||
186: "JS_FUNCTION_PROXY_TYPE",
|
||||
178: "DEBUG_INFO_TYPE",
|
||||
179: "BREAK_POINT_INFO_TYPE",
|
||||
139: "FIXED_INT8_ARRAY_TYPE",
|
||||
140: "FIXED_UINT8_ARRAY_TYPE",
|
||||
141: "FIXED_INT16_ARRAY_TYPE",
|
||||
142: "FIXED_UINT16_ARRAY_TYPE",
|
||||
143: "FIXED_INT32_ARRAY_TYPE",
|
||||
144: "FIXED_UINT32_ARRAY_TYPE",
|
||||
145: "FIXED_FLOAT32_ARRAY_TYPE",
|
||||
146: "FIXED_FLOAT64_ARRAY_TYPE",
|
||||
147: "FIXED_UINT8_CLAMPED_ARRAY_TYPE",
|
||||
149: "FILLER_TYPE",
|
||||
150: "DECLARED_ACCESSOR_DESCRIPTOR_TYPE",
|
||||
151: "DECLARED_ACCESSOR_INFO_TYPE",
|
||||
152: "EXECUTABLE_ACCESSOR_INFO_TYPE",
|
||||
153: "ACCESSOR_PAIR_TYPE",
|
||||
154: "ACCESS_CHECK_INFO_TYPE",
|
||||
155: "INTERCEPTOR_INFO_TYPE",
|
||||
156: "CALL_HANDLER_INFO_TYPE",
|
||||
157: "FUNCTION_TEMPLATE_INFO_TYPE",
|
||||
158: "OBJECT_TEMPLATE_INFO_TYPE",
|
||||
159: "SIGNATURE_INFO_TYPE",
|
||||
160: "TYPE_SWITCH_INFO_TYPE",
|
||||
162: "ALLOCATION_MEMENTO_TYPE",
|
||||
161: "ALLOCATION_SITE_TYPE",
|
||||
163: "SCRIPT_TYPE",
|
||||
164: "CODE_CACHE_TYPE",
|
||||
165: "POLYMORPHIC_CODE_CACHE_TYPE",
|
||||
166: "TYPE_FEEDBACK_INFO_TYPE",
|
||||
167: "ALIASED_ARGUMENTS_ENTRY_TYPE",
|
||||
168: "BOX_TYPE",
|
||||
177: "PROTOTYPE_INFO_TYPE",
|
||||
178: "SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION_TYPE",
|
||||
171: "FIXED_ARRAY_TYPE",
|
||||
148: "FIXED_DOUBLE_ARRAY_TYPE",
|
||||
172: "SHARED_FUNCTION_INFO_TYPE",
|
||||
174: "WEAK_CELL_TYPE",
|
||||
175: "TRANSITION_ARRAY_TYPE",
|
||||
181: "JS_MESSAGE_OBJECT_TYPE",
|
||||
180: "JS_VALUE_TYPE",
|
||||
182: "JS_DATE_TYPE",
|
||||
183: "JS_OBJECT_TYPE",
|
||||
184: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
|
||||
185: "JS_GENERATOR_OBJECT_TYPE",
|
||||
186: "JS_MODULE_TYPE",
|
||||
187: "JS_GLOBAL_OBJECT_TYPE",
|
||||
188: "JS_GLOBAL_PROXY_TYPE",
|
||||
189: "JS_ARRAY_TYPE",
|
||||
190: "JS_ARRAY_BUFFER_TYPE",
|
||||
191: "JS_TYPED_ARRAY_TYPE",
|
||||
192: "JS_DATA_VIEW_TYPE",
|
||||
179: "JS_PROXY_TYPE",
|
||||
193: "JS_SET_TYPE",
|
||||
194: "JS_MAP_TYPE",
|
||||
195: "JS_SET_ITERATOR_TYPE",
|
||||
196: "JS_MAP_ITERATOR_TYPE",
|
||||
197: "JS_ITERATOR_RESULT_TYPE",
|
||||
198: "JS_WEAK_MAP_TYPE",
|
||||
199: "JS_WEAK_SET_TYPE",
|
||||
200: "JS_PROMISE_TYPE",
|
||||
201: "JS_REGEXP_TYPE",
|
||||
202: "JS_BOUND_FUNCTION_TYPE",
|
||||
203: "JS_FUNCTION_TYPE",
|
||||
169: "DEBUG_INFO_TYPE",
|
||||
170: "BREAK_POINT_INFO_TYPE",
|
||||
}
|
||||
|
||||
# List of known V8 maps.
|
||||
KNOWN_MAPS = {
|
||||
0x08081: (136, "ByteArrayMap"),
|
||||
0x080ad: (129, "MetaMap"),
|
||||
0x080ad: (132, "MetaMap"),
|
||||
0x080d9: (131, "NullMap"),
|
||||
0x08105: (180, "FixedArrayMap"),
|
||||
0x08105: (171, "FixedArrayMap"),
|
||||
0x08131: (4, "OneByteInternalizedStringMap"),
|
||||
0x0815d: (183, "WeakCellMap"),
|
||||
0x08189: (131, "TheHoleMap"),
|
||||
0x081b5: (138, "FreeSpaceMap"),
|
||||
0x081e1: (158, "OnePointerFillerMap"),
|
||||
0x0820d: (158, "TwoPointerFillerMap"),
|
||||
0x08239: (131, "UndefinedMap"),
|
||||
0x08265: (132, "HeapNumberMap"),
|
||||
0x08291: (131, "BooleanMap"),
|
||||
0x082bd: (131, "UninitializedMap"),
|
||||
0x082e9: (182, "CellMap"),
|
||||
0x08315: (184, "GlobalPropertyCellMap"),
|
||||
0x08341: (181, "SharedFunctionInfoMap"),
|
||||
0x0836d: (133, "MutableHeapNumberMap"),
|
||||
0x08399: (134, "Float32x4Map"),
|
||||
0x083c5: (180, "NativeContextMap"),
|
||||
0x083f1: (130, "CodeMap"),
|
||||
0x0841d: (180, "ScopeInfoMap"),
|
||||
0x08449: (180, "FixedCOWArrayMap"),
|
||||
0x08475: (157, "FixedDoubleArrayMap"),
|
||||
0x084a1: (68, "OneByteStringMap"),
|
||||
0x084cd: (180, "FunctionContextMap"),
|
||||
0x084f9: (131, "NoInterceptorResultSentinelMap"),
|
||||
0x08525: (131, "ArgumentsMarkerMap"),
|
||||
0x08551: (131, "ExceptionMap"),
|
||||
0x0857d: (131, "TerminationExceptionMap"),
|
||||
0x085a9: (180, "HashTableMap"),
|
||||
0x085d5: (180, "OrderedHashTableMap"),
|
||||
0x08601: (128, "SymbolMap"),
|
||||
0x0862d: (64, "StringMap"),
|
||||
0x08659: (69, "ConsOneByteStringMap"),
|
||||
0x08685: (65, "ConsStringMap"),
|
||||
0x086b1: (67, "SlicedStringMap"),
|
||||
0x086dd: (71, "SlicedOneByteStringMap"),
|
||||
0x08709: (66, "ExternalStringMap"),
|
||||
0x08735: (74, "ExternalStringWithOneByteDataMap"),
|
||||
0x08761: (70, "ExternalOneByteStringMap"),
|
||||
0x0878d: (70, "NativeSourceStringMap"),
|
||||
0x087b9: (82, "ShortExternalStringMap"),
|
||||
0x087e5: (90, "ShortExternalStringWithOneByteDataMap"),
|
||||
0x08811: (0, "InternalizedStringMap"),
|
||||
0x0883d: (2, "ExternalInternalizedStringMap"),
|
||||
0x08869: (10, "ExternalInternalizedStringWithOneByteDataMap"),
|
||||
0x08895: (6, "ExternalOneByteInternalizedStringMap"),
|
||||
0x088c1: (18, "ShortExternalInternalizedStringMap"),
|
||||
0x088ed: (26, "ShortExternalInternalizedStringWithOneByteDataMap"),
|
||||
0x08919: (22, "ShortExternalOneByteInternalizedStringMap"),
|
||||
0x08945: (86, "ShortExternalOneByteStringMap"),
|
||||
0x08971: (139, "ExternalInt8ArrayMap"),
|
||||
0x0899d: (140, "ExternalUint8ArrayMap"),
|
||||
0x089c9: (141, "ExternalInt16ArrayMap"),
|
||||
0x089f5: (142, "ExternalUint16ArrayMap"),
|
||||
0x08a21: (143, "ExternalInt32ArrayMap"),
|
||||
0x08a4d: (144, "ExternalUint32ArrayMap"),
|
||||
0x08a79: (145, "ExternalFloat32ArrayMap"),
|
||||
0x08aa5: (146, "ExternalFloat64ArrayMap"),
|
||||
0x08ad1: (147, "ExternalUint8ClampedArrayMap"),
|
||||
0x08afd: (149, "FixedUint8ArrayMap"),
|
||||
0x08b29: (148, "FixedInt8ArrayMap"),
|
||||
0x08b55: (151, "FixedUint16ArrayMap"),
|
||||
0x08b81: (150, "FixedInt16ArrayMap"),
|
||||
0x08bad: (153, "FixedUint32ArrayMap"),
|
||||
0x08bd9: (152, "FixedInt32ArrayMap"),
|
||||
0x08c05: (154, "FixedFloat32ArrayMap"),
|
||||
0x08c31: (155, "FixedFloat64ArrayMap"),
|
||||
0x08c5d: (156, "FixedUint8ClampedArrayMap"),
|
||||
0x08c89: (180, "SloppyArgumentsElementsMap"),
|
||||
0x08cb5: (180, "CatchContextMap"),
|
||||
0x08ce1: (180, "WithContextMap"),
|
||||
0x08d0d: (180, "BlockContextMap"),
|
||||
0x08d39: (180, "ModuleContextMap"),
|
||||
0x08d65: (180, "ScriptContextMap"),
|
||||
0x08d91: (180, "ScriptContextTableMap"),
|
||||
0x08dbd: (189, "JSMessageObjectMap"),
|
||||
0x08de9: (135, "ForeignMap"),
|
||||
0x08e15: (191, "NeanderMap"),
|
||||
0x08e41: (191, "ExternalMap"),
|
||||
0x08e6d: (171, "AllocationMementoMap"),
|
||||
0x08e99: (170, "AllocationSiteMap"),
|
||||
0x08ec5: (174, "PolymorphicCodeCacheMap"),
|
||||
0x08ef1: (172, "ScriptMap"),
|
||||
0x09101: (161, "ExecutableAccessorInfoMap"),
|
||||
0x09159: (162, "AccessorPairMap"),
|
||||
0x09209: (185, "PrototypeInfoMap"),
|
||||
0x09839: (137, "BytecodeArrayMap"),
|
||||
0x09865: (177, "BoxMap"),
|
||||
0x09891: (163, "AccessCheckInfoMap"),
|
||||
0x098bd: (164, "InterceptorInfoMap"),
|
||||
0x098e9: (165, "CallHandlerInfoMap"),
|
||||
0x09915: (166, "FunctionTemplateInfoMap"),
|
||||
0x09941: (167, "ObjectTemplateInfoMap"),
|
||||
0x09999: (173, "CodeCacheMap"),
|
||||
0x099c5: (175, "TypeFeedbackInfoMap"),
|
||||
0x099f1: (176, "AliasedArgumentsEntryMap"),
|
||||
0x09a1d: (178, "DebugInfoMap"),
|
||||
0x09a49: (179, "BreakPointInfoMap"),
|
||||
0x0815d: (138, "FreeSpaceMap"),
|
||||
0x08189: (149, "OnePointerFillerMap"),
|
||||
0x081b5: (149, "TwoPointerFillerMap"),
|
||||
0x081e1: (131, "UndefinedMap"),
|
||||
0x0820d: (129, "HeapNumberMap"),
|
||||
0x08239: (131, "TheHoleMap"),
|
||||
0x08265: (131, "BooleanMap"),
|
||||
0x08291: (131, "UninitializedMap"),
|
||||
0x082bd: (173, "CellMap"),
|
||||
0x082e9: (176, "GlobalPropertyCellMap"),
|
||||
0x08315: (172, "SharedFunctionInfoMap"),
|
||||
0x08341: (134, "MutableHeapNumberMap"),
|
||||
0x0836d: (130, "Float32x4Map"),
|
||||
0x08399: (130, "Int32x4Map"),
|
||||
0x083c5: (130, "Uint32x4Map"),
|
||||
0x083f1: (130, "Bool32x4Map"),
|
||||
0x0841d: (130, "Int16x8Map"),
|
||||
0x08449: (130, "Uint16x8Map"),
|
||||
0x08475: (130, "Bool16x8Map"),
|
||||
0x084a1: (130, "Int8x16Map"),
|
||||
0x084cd: (130, "Uint8x16Map"),
|
||||
0x084f9: (130, "Bool8x16Map"),
|
||||
0x08525: (171, "NativeContextMap"),
|
||||
0x08551: (133, "CodeMap"),
|
||||
0x0857d: (171, "ScopeInfoMap"),
|
||||
0x085a9: (171, "FixedCOWArrayMap"),
|
||||
0x085d5: (148, "FixedDoubleArrayMap"),
|
||||
0x08601: (174, "WeakCellMap"),
|
||||
0x0862d: (175, "TransitionArrayMap"),
|
||||
0x08659: (68, "OneByteStringMap"),
|
||||
0x08685: (171, "FunctionContextMap"),
|
||||
0x086b1: (131, "NoInterceptorResultSentinelMap"),
|
||||
0x086dd: (131, "ArgumentsMarkerMap"),
|
||||
0x08709: (131, "ExceptionMap"),
|
||||
0x08735: (131, "TerminationExceptionMap"),
|
||||
0x08761: (171, "HashTableMap"),
|
||||
0x0878d: (171, "OrderedHashTableMap"),
|
||||
0x087b9: (128, "SymbolMap"),
|
||||
0x087e5: (64, "StringMap"),
|
||||
0x08811: (69, "ConsOneByteStringMap"),
|
||||
0x0883d: (65, "ConsStringMap"),
|
||||
0x08869: (67, "SlicedStringMap"),
|
||||
0x08895: (71, "SlicedOneByteStringMap"),
|
||||
0x088c1: (66, "ExternalStringMap"),
|
||||
0x088ed: (74, "ExternalStringWithOneByteDataMap"),
|
||||
0x08919: (70, "ExternalOneByteStringMap"),
|
||||
0x08945: (70, "NativeSourceStringMap"),
|
||||
0x08971: (82, "ShortExternalStringMap"),
|
||||
0x0899d: (90, "ShortExternalStringWithOneByteDataMap"),
|
||||
0x089c9: (0, "InternalizedStringMap"),
|
||||
0x089f5: (2, "ExternalInternalizedStringMap"),
|
||||
0x08a21: (10, "ExternalInternalizedStringWithOneByteDataMap"),
|
||||
0x08a4d: (6, "ExternalOneByteInternalizedStringMap"),
|
||||
0x08a79: (18, "ShortExternalInternalizedStringMap"),
|
||||
0x08aa5: (26, "ShortExternalInternalizedStringWithOneByteDataMap"),
|
||||
0x08ad1: (22, "ShortExternalOneByteInternalizedStringMap"),
|
||||
0x08afd: (86, "ShortExternalOneByteStringMap"),
|
||||
0x08b29: (140, "FixedUint8ArrayMap"),
|
||||
0x08b55: (139, "FixedInt8ArrayMap"),
|
||||
0x08b81: (142, "FixedUint16ArrayMap"),
|
||||
0x08bad: (141, "FixedInt16ArrayMap"),
|
||||
0x08bd9: (144, "FixedUint32ArrayMap"),
|
||||
0x08c05: (143, "FixedInt32ArrayMap"),
|
||||
0x08c31: (145, "FixedFloat32ArrayMap"),
|
||||
0x08c5d: (146, "FixedFloat64ArrayMap"),
|
||||
0x08c89: (147, "FixedUint8ClampedArrayMap"),
|
||||
0x08cb5: (171, "SloppyArgumentsElementsMap"),
|
||||
0x08ce1: (171, "CatchContextMap"),
|
||||
0x08d0d: (171, "WithContextMap"),
|
||||
0x08d39: (171, "BlockContextMap"),
|
||||
0x08d65: (171, "ModuleContextMap"),
|
||||
0x08d91: (171, "ScriptContextMap"),
|
||||
0x08dbd: (171, "ScriptContextTableMap"),
|
||||
0x08de9: (181, "JSMessageObjectMap"),
|
||||
0x08e15: (135, "ForeignMap"),
|
||||
0x08e41: (183, "NeanderMap"),
|
||||
0x08e6d: (183, "ExternalMap"),
|
||||
0x08e99: (162, "AllocationMementoMap"),
|
||||
0x08ec5: (161, "AllocationSiteMap"),
|
||||
0x08ef1: (165, "PolymorphicCodeCacheMap"),
|
||||
0x08f1d: (163, "ScriptMap"),
|
||||
0x08f75: (137, "BytecodeArrayMap"),
|
||||
0x08fa1: (168, "BoxMap"),
|
||||
0x08fcd: (152, "ExecutableAccessorInfoMap"),
|
||||
0x08ff9: (153, "AccessorPairMap"),
|
||||
0x09025: (154, "AccessCheckInfoMap"),
|
||||
0x09051: (155, "InterceptorInfoMap"),
|
||||
0x0907d: (156, "CallHandlerInfoMap"),
|
||||
0x090a9: (157, "FunctionTemplateInfoMap"),
|
||||
0x090d5: (158, "ObjectTemplateInfoMap"),
|
||||
0x09101: (164, "CodeCacheMap"),
|
||||
0x0912d: (166, "TypeFeedbackInfoMap"),
|
||||
0x09159: (167, "AliasedArgumentsEntryMap"),
|
||||
0x09185: (169, "DebugInfoMap"),
|
||||
0x091b1: (170, "BreakPointInfoMap"),
|
||||
0x091dd: (177, "PrototypeInfoMap"),
|
||||
0x09209: (178, "SloppyBlockWithEvalContextExtensionMap"),
|
||||
}
|
||||
|
||||
# List of known V8 objects.
|
||||
KNOWN_OBJECTS = {
|
||||
("OLD_SPACE", 0x08081): "NullValue",
|
||||
("OLD_SPACE", 0x08091): "EmptyDescriptorArray",
|
||||
("OLD_SPACE", 0x08099): "EmptyFixedArray",
|
||||
("OLD_SPACE", 0x080bd): "TheHoleValue",
|
||||
("OLD_SPACE", 0x080dd): "UndefinedValue",
|
||||
("OLD_SPACE", 0x08105): "NanValue",
|
||||
("OLD_SPACE", 0x08115): "TrueValue",
|
||||
("OLD_SPACE", 0x08135): "FalseValue",
|
||||
("OLD_SPACE", 0x08159): "empty_string",
|
||||
("OLD_SPACE", 0x08165): "UninitializedValue",
|
||||
("OLD_SPACE", 0x08191): "EmptyByteArray",
|
||||
("OLD_SPACE", 0x08199): "NoInterceptorResultSentinel",
|
||||
("OLD_SPACE", 0x081d5): "ArgumentsMarker",
|
||||
("OLD_SPACE", 0x08201): "Exception",
|
||||
("OLD_SPACE", 0x08229): "TerminationException",
|
||||
("OLD_SPACE", 0x0825d): "NumberStringCache",
|
||||
("OLD_SPACE", 0x08a65): "SingleCharacterStringCache",
|
||||
("OLD_SPACE", 0x08efd): "StringSplitCache",
|
||||
("OLD_SPACE", 0x09305): "RegExpMultipleCache",
|
||||
("OLD_SPACE", 0x0970d): "EmptyExternalInt8Array",
|
||||
("OLD_SPACE", 0x09719): "EmptyExternalUint8Array",
|
||||
("OLD_SPACE", 0x09725): "EmptyExternalInt16Array",
|
||||
("OLD_SPACE", 0x09731): "EmptyExternalUint16Array",
|
||||
("OLD_SPACE", 0x0973d): "EmptyExternalInt32Array",
|
||||
("OLD_SPACE", 0x09749): "EmptyExternalUint32Array",
|
||||
("OLD_SPACE", 0x09755): "EmptyExternalFloat32Array",
|
||||
("OLD_SPACE", 0x09761): "EmptyExternalFloat64Array",
|
||||
("OLD_SPACE", 0x0976d): "EmptyExternalUint8ClampedArray",
|
||||
("OLD_SPACE", 0x09779): "EmptyFixedUint8Array",
|
||||
("OLD_SPACE", 0x09789): "EmptyFixedInt8Array",
|
||||
("OLD_SPACE", 0x09799): "EmptyFixedUint16Array",
|
||||
("OLD_SPACE", 0x097a9): "EmptyFixedInt16Array",
|
||||
("OLD_SPACE", 0x097b9): "EmptyFixedUint32Array",
|
||||
("OLD_SPACE", 0x097c9): "EmptyFixedInt32Array",
|
||||
("OLD_SPACE", 0x097d9): "EmptyFixedFloat32Array",
|
||||
("OLD_SPACE", 0x097e9): "EmptyFixedFloat64Array",
|
||||
("OLD_SPACE", 0x097f9): "EmptyFixedUint8ClampedArray",
|
||||
("OLD_SPACE", 0x0980d): "InfinityValue",
|
||||
("OLD_SPACE", 0x0981d): "MinusZeroValue",
|
||||
("OLD_SPACE", 0x0982d): "MinusInfinityValue",
|
||||
("OLD_SPACE", 0x09839): "MessageListeners",
|
||||
("OLD_SPACE", 0x09855): "CodeStubs",
|
||||
("OLD_SPACE", 0x0e52d): "ArrayProtector",
|
||||
("OLD_SPACE", 0x0e9a1): "KeyedLoadDummyVector",
|
||||
("OLD_SPACE", 0x13ded): "NonMonomorphicCache",
|
||||
("OLD_SPACE", 0x14131): "PolymorphicCodeCache",
|
||||
("OLD_SPACE", 0x14139): "NativesSourceCache",
|
||||
("OLD_SPACE", 0x14429): "ExperimentalNativesSourceCache",
|
||||
("OLD_SPACE", 0x14461): "ExtraNativesSourceCache",
|
||||
("OLD_SPACE", 0x1446d): "CodeStubNativesSourceCache",
|
||||
("OLD_SPACE", 0x1448d): "EmptyScript",
|
||||
("OLD_SPACE", 0x144cd): "IntrinsicFunctionNames",
|
||||
("OLD_SPACE", 0x240e1): "UndefinedCell",
|
||||
("OLD_SPACE", 0x240e9): "ObservationState",
|
||||
("OLD_SPACE", 0x240f5): "SymbolRegistry",
|
||||
("OLD_SPACE", 0x24f9d): "EmptySlowElementDictionary",
|
||||
("OLD_SPACE", 0x24fc5): "AllocationSitesScratchpad",
|
||||
("OLD_SPACE", 0x253cd): "WeakObjectToCodeTable",
|
||||
("OLD_SPACE", 0x25461): "EmptyPropertyCell",
|
||||
("OLD_SPACE", 0x25471): "CodeStubContext",
|
||||
("OLD_SPACE", 0x2ba11): "CodeStubExportsObject",
|
||||
("OLD_SPACE", 0x2be89): "EmptyBytecodeArray",
|
||||
("OLD_SPACE", 0x594dd): "StringTable",
|
||||
("CODE_SPACE", 0x16341): "JsEntryCode",
|
||||
("CODE_SPACE", 0x26a61): "JsConstructEntryCode",
|
||||
("OLD_SPACE", 0x08095): "EmptyDescriptorArray",
|
||||
("OLD_SPACE", 0x0809d): "EmptyFixedArray",
|
||||
("OLD_SPACE", 0x080c9): "UndefinedValue",
|
||||
("OLD_SPACE", 0x080f5): "NanValue",
|
||||
("OLD_SPACE", 0x08105): "TheHoleValue",
|
||||
("OLD_SPACE", 0x08129): "TrueValue",
|
||||
("OLD_SPACE", 0x08161): "FalseValue",
|
||||
("OLD_SPACE", 0x08189): "empty_string",
|
||||
("OLD_SPACE", 0x08195): "hidden_string",
|
||||
("OLD_SPACE", 0x081a1): "UninitializedValue",
|
||||
("OLD_SPACE", 0x081d1): "EmptyByteArray",
|
||||
("OLD_SPACE", 0x081d9): "NoInterceptorResultSentinel",
|
||||
("OLD_SPACE", 0x08219): "ArgumentsMarker",
|
||||
("OLD_SPACE", 0x08249): "Exception",
|
||||
("OLD_SPACE", 0x08275): "TerminationException",
|
||||
("OLD_SPACE", 0x082ad): "NumberStringCache",
|
||||
("OLD_SPACE", 0x08ab5): "SingleCharacterStringCache",
|
||||
("OLD_SPACE", 0x08f4d): "StringSplitCache",
|
||||
("OLD_SPACE", 0x09355): "RegExpMultipleCache",
|
||||
("OLD_SPACE", 0x0975d): "EmptyFixedUint8Array",
|
||||
("OLD_SPACE", 0x0976d): "EmptyFixedInt8Array",
|
||||
("OLD_SPACE", 0x0977d): "EmptyFixedUint16Array",
|
||||
("OLD_SPACE", 0x0978d): "EmptyFixedInt16Array",
|
||||
("OLD_SPACE", 0x0979d): "EmptyFixedUint32Array",
|
||||
("OLD_SPACE", 0x097ad): "EmptyFixedInt32Array",
|
||||
("OLD_SPACE", 0x097bd): "EmptyFixedFloat32Array",
|
||||
("OLD_SPACE", 0x097cd): "EmptyFixedFloat64Array",
|
||||
("OLD_SPACE", 0x097dd): "EmptyFixedUint8ClampedArray",
|
||||
("OLD_SPACE", 0x097ed): "InfinityValue",
|
||||
("OLD_SPACE", 0x097fd): "MinusZeroValue",
|
||||
("OLD_SPACE", 0x0980d): "MinusInfinityValue",
|
||||
("OLD_SPACE", 0x0981d): "MessageListeners",
|
||||
("OLD_SPACE", 0x09839): "CodeStubs",
|
||||
("OLD_SPACE", 0x10201): "DummyVector",
|
||||
("OLD_SPACE", 0x1403d): "NonMonomorphicCache",
|
||||
("OLD_SPACE", 0x14651): "PolymorphicCodeCache",
|
||||
("OLD_SPACE", 0x14659): "NativesSourceCache",
|
||||
("OLD_SPACE", 0x148f5): "ExperimentalNativesSourceCache",
|
||||
("OLD_SPACE", 0x14929): "ExtraNativesSourceCache",
|
||||
("OLD_SPACE", 0x14949): "ExperimentalExtraNativesSourceCache",
|
||||
("OLD_SPACE", 0x14955): "EmptyScript",
|
||||
("OLD_SPACE", 0x14995): "IntrinsicFunctionNames",
|
||||
("OLD_SPACE", 0x2e73d): "UndefinedCell",
|
||||
("OLD_SPACE", 0x2e745): "ObservationState",
|
||||
("OLD_SPACE", 0x2e751): "ScriptList",
|
||||
("OLD_SPACE", 0x2e8d9): "ClearedOptimizedCodeMap",
|
||||
("OLD_SPACE", 0x2e8e5): "EmptyWeakCell",
|
||||
("OLD_SPACE", 0x54715): "EmptySlowElementDictionary",
|
||||
("OLD_SPACE", 0x54761): "WeakObjectToCodeTable",
|
||||
("OLD_SPACE", 0x54875): "ArrayProtector",
|
||||
("OLD_SPACE", 0x54885): "EmptyPropertyCell",
|
||||
("OLD_SPACE", 0x54895): "NoScriptSharedFunctionInfos",
|
||||
("OLD_SPACE", 0x5711d): "InterpreterTable",
|
||||
("OLD_SPACE", 0x57325): "EmptyBytecodeArray",
|
||||
("OLD_SPACE", 0x5a2d1): "StringTable",
|
||||
("CODE_SPACE", 0x1a2a1): "JsEntryCode",
|
||||
("CODE_SPACE", 0x1f081): "JsConstructEntryCode",
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user