[heap] Improve accounting of PagedSpace::CommittedPhysicalMemory()

Instead of using the high water mark for determining this metric, we use
a bitset for all active/used system pages on a V8 heap page. Each time
when allocating a LAB on a page, we add the pages of that memory range
to that bitset. During sweeping we rebuild that bitset from scratch and
replace it with the old one in case free pages are discarded by the GC.
We DCHECK here that the sweeper only ever removes pages. This has the
nice benefit of ensuring that we don't miss any allocations (like we
do now for concurrent allocations).

CommittedPhysicalMemory for a page is then calculated by counting the
set bits in the bitset and multiplying it with the system page size.
This should be simpler to verify and track the "real" effective size
more precisely.

One case where we are partially less precise than the current
implementation is for LABs. In order to reduce complexity we now treat
all pages of a LAB allocation as active immediately. In the current
implementation we tried to only account the actual used part of the LAB
when changing the LAB later. This is more complex to track correctly
but also doesn't account the currently used LAB in effective size.

Change-Id: Ia83df9ad5fbb852f0717c4c396b5074604bd21e9
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3497363
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: Dominik Inführ <dinfuehr@chromium.org>
Cr-Commit-Position: refs/heads/main@{#79428}
This commit is contained in:
Dominik Inführ 2022-03-09 17:49:56 +01:00 committed by V8 LUCI CQ
parent 35703d9cad
commit 25981026dc
22 changed files with 672 additions and 300 deletions

View File

@ -1295,6 +1295,8 @@ filegroup(
"src/handles/maybe-handles.h",
"src/handles/persistent-handles.cc",
"src/handles/persistent-handles.h",
"src/heap/base/active-system-pages.cc",
"src/heap/base/active-system-pages.h",
"src/heap/allocation-observer.cc",
"src/heap/allocation-observer.h",
"src/heap/allocation-result.h",
@ -2935,6 +2937,8 @@ filegroup(
filegroup(
name = "v8_heap_base_files",
srcs = [
"src/heap/base/active-system-pages.cc",
"src/heap/base/active-system-pages.h",
"src/heap/base/stack.cc",
"src/heap/base/stack.h",
"src/heap/base/worklist.cc",

View File

@ -3852,6 +3852,7 @@ v8_header_set("v8_internal_headers") {
":cppgc_headers",
":generate_bytecode_builtins_list",
":run_torque",
":v8_heap_base_headers",
":v8_libbase",
]
}
@ -5454,12 +5455,23 @@ v8_source_set("v8_bigint") {
configs = [ ":internal_config" ]
}
v8_source_set("v8_heap_base_headers") {
sources = [
"src/heap/base/active-system-pages.h",
"src/heap/base/stack.h",
"src/heap/base/worklist.h",
]
configs = [ ":internal_config" ]
public_deps = [ ":v8_libbase" ]
}
v8_source_set("v8_heap_base") {
sources = [
"src/heap/base/active-system-pages.cc",
"src/heap/base/stack.cc",
"src/heap/base/stack.h",
"src/heap/base/worklist.cc",
"src/heap/base/worklist.h",
]
if (is_clang || !is_win) {
@ -5496,7 +5508,10 @@ v8_source_set("v8_heap_base") {
configs = [ ":internal_config" ]
public_deps = [ ":v8_libbase" ]
public_deps = [
":v8_heap_base_headers",
":v8_libbase",
]
}
# This is split out to be a non-code containing target that the Chromium browser

View File

@ -918,6 +918,8 @@ enum class CompactionSpaceKind {
enum Executability { NOT_EXECUTABLE, EXECUTABLE };
enum PageSize { kRegular, kLarge };
enum class CodeFlushMode {
kFlushBytecode,
kFlushBaselineCode,

View File

@ -0,0 +1,69 @@
// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/heap/base/active-system-pages.h"
#include "src/base/bits.h"
#include "src/base/macros.h"
namespace heap {
namespace base {
size_t ActiveSystemPages::Init(size_t header_size, size_t page_size_bits,
size_t user_page_size) {
#if DEBUG
size_t page_size = 1 << page_size_bits;
DCHECK_LE(RoundUp(user_page_size, page_size) >> page_size_bits,
ActiveSystemPages::kMaxPages);
#endif // DEBUG
Clear();
return Add(0, header_size, page_size_bits);
}
size_t ActiveSystemPages::Add(uintptr_t start, uintptr_t end,
size_t page_size_bits) {
const size_t page_size = 1 << page_size_bits;
DCHECK_LE(start, end);
DCHECK_LE(end, kMaxPages * page_size);
// Make sure we actually get the bitcount as argument.
DCHECK_LT(page_size_bits, sizeof(uintptr_t) * CHAR_BIT);
const uintptr_t start_page_bit =
RoundDown(start, page_size) >> page_size_bits;
const uintptr_t end_page_bit = RoundUp(end, page_size) >> page_size_bits;
DCHECK_LE(start_page_bit, end_page_bit);
const uintptr_t bits = end_page_bit - start_page_bit;
DCHECK_LE(bits, kMaxPages);
const bitset_t mask = bits == kMaxPages
? int64_t{-1}
: ((uint64_t{1} << bits) - 1) << start_page_bit;
const bitset_t added_pages = ~value_ & mask;
value_ |= mask;
return added_pages.count();
}
size_t ActiveSystemPages::Reduce(ActiveSystemPages updated_value) {
DCHECK_EQ(~value_ & updated_value.value_, 0);
const bitset_t removed_pages(value_ & ~updated_value.value_);
value_ = updated_value.value_;
return removed_pages.count();
}
size_t ActiveSystemPages::Clear() {
const size_t removed_pages = value_.count();
value_ = 0;
return removed_pages;
}
size_t ActiveSystemPages::Size(size_t page_size_bits) const {
// Make sure we don't get the full page size as argument.
DCHECK_LT(page_size_bits, sizeof(uintptr_t) * CHAR_BIT);
return value_.count() * (size_t{1} << page_size_bits);
}
} // namespace base
} // namespace heap

View File

@ -0,0 +1,51 @@
// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_HEAP_BASE_ACTIVE_SYSTEM_PAGES_H_
#define V8_HEAP_BASE_ACTIVE_SYSTEM_PAGES_H_
#include <bitset>
#include <cstdint>
#include "src/base/macros.h"
namespace heap {
namespace base {
// Class implements a bitset of system pages on a heap page.
class ActiveSystemPages final {
public:
// Defines the maximum number of system pages that can be tracked in one
// instance.
static constexpr size_t kMaxPages = 64;
// Initializes the set of active pages to the system pages for the header.
V8_EXPORT_PRIVATE size_t Init(size_t header_size, size_t page_size_bits,
size_t user_page_size);
// Adds the pages for this memory range. Returns the number of freshly added
// pages.
V8_EXPORT_PRIVATE size_t Add(size_t start, size_t end, size_t page_size_bits);
// Replaces the current bitset with the given argument. The new bitset needs
// to be a proper subset of the current pages, which means this operation
// can't add pages. Returns the number of removed pages.
V8_EXPORT_PRIVATE size_t Reduce(ActiveSystemPages updated_value);
// Removes all pages. Returns the number of removed pages.
V8_EXPORT_PRIVATE size_t Clear();
// Returns the memory used with the given page size.
V8_EXPORT_PRIVATE size_t Size(size_t page_size_bits) const;
private:
using bitset_t = std::bitset<kMaxPages>;
bitset_t value_;
};
} // namespace base
} // namespace heap
#endif // V8_HEAP_BASE_ACTIVE_SYSTEM_PAGES_H_

View File

@ -4569,6 +4569,10 @@ void Heap::Verify() {
code_lo_space_->Verify(isolate());
if (new_lo_space_) new_lo_space_->Verify(isolate());
isolate()->string_table()->VerifyIfOwnedBy(isolate());
#if DEBUG
VerifyCommittedPhysicalMemory();
#endif // DEBUG
}
void Heap::VerifyReadOnlyHeap() {
@ -4760,7 +4764,15 @@ void Heap::VerifyCountersBeforeConcurrentSweeping() {
space->VerifyCountersBeforeConcurrentSweeping();
}
}
#endif
void Heap::VerifyCommittedPhysicalMemory() {
PagedSpaceIterator spaces(this);
for (PagedSpace* space = spaces.Next(); space != nullptr;
space = spaces.Next()) {
space->VerifyCommittedPhysicalMemory();
}
}
#endif // DEBUG
void Heap::ZapFromSpace() {
if (!new_space_ || !new_space_->IsFromSpaceCommitted()) return;

View File

@ -1583,13 +1583,14 @@ class Heap {
#ifdef DEBUG
void VerifyCountersAfterSweeping();
void VerifyCountersBeforeConcurrentSweeping();
void VerifyCommittedPhysicalMemory();
void Print();
void PrintHandles();
// Report code statistics.
void ReportCodeStatistics(const char* title);
#endif
#endif // DEBUG
void* GetRandomMmapAddr() {
void* result = v8::internal::GetRandomMmapAddr();
#if V8_TARGET_ARCH_X64

View File

@ -402,14 +402,15 @@ V8_EXPORT_PRIVATE BasicMemoryChunk* MemoryAllocator::AllocateBasicChunk(
MemoryChunk* MemoryAllocator::AllocateChunk(size_t reserve_area_size,
size_t commit_area_size,
Executability executable,
PageSize page_size,
BaseSpace* owner) {
BasicMemoryChunk* basic_chunk = AllocateBasicChunk(
reserve_area_size, commit_area_size, executable, owner);
if (basic_chunk == nullptr) return nullptr;
MemoryChunk* chunk =
MemoryChunk::Initialize(basic_chunk, isolate_->heap(), executable);
MemoryChunk* chunk = MemoryChunk::Initialize(basic_chunk, isolate_->heap(),
executable, page_size);
#ifdef DEBUG
if (chunk->executable()) RegisterExecutableMemoryChunk(chunk);
@ -562,7 +563,7 @@ Page* MemoryAllocator::AllocatePage(MemoryAllocator::AllocationMode alloc_mode,
chunk = AllocatePagePooled(owner);
}
if (chunk == nullptr) {
chunk = AllocateChunk(size, size, executable, owner);
chunk = AllocateChunk(size, size, executable, PageSize::kRegular, owner);
}
if (chunk == nullptr) return nullptr;
return owner->InitializePage(chunk);
@ -585,7 +586,8 @@ MemoryAllocator::RemapSharedPage(
LargePage* MemoryAllocator::AllocateLargePage(size_t size,
LargeObjectSpace* owner,
Executability executable) {
MemoryChunk* chunk = AllocateChunk(size, size, executable, owner);
MemoryChunk* chunk =
AllocateChunk(size, size, executable, PageSize::kLarge, owner);
if (chunk == nullptr) return nullptr;
return LargePage::Initialize(isolate_->heap(), chunk, executable);
}
@ -609,7 +611,8 @@ MemoryChunk* MemoryAllocator::AllocatePagePooled(Space* owner) {
BasicMemoryChunk* basic_chunk =
BasicMemoryChunk::Initialize(isolate_->heap(), start, size, area_start,
area_end, owner, std::move(reservation));
MemoryChunk::Initialize(basic_chunk, isolate_->heap(), NOT_EXECUTABLE);
MemoryChunk::Initialize(basic_chunk, isolate_->heap(), NOT_EXECUTABLE,
PageSize::kRegular);
size_ += size;
return chunk;
}

View File

@ -222,6 +222,7 @@ class MemoryAllocator {
V8_EXPORT_PRIVATE MemoryChunk* AllocateChunk(size_t reserve_area_size,
size_t commit_area_size,
Executability executable,
PageSize page_size,
BaseSpace* space);
// Partially release |bytes_to_free| bytes starting at |start_free|. Note that

View File

@ -5,6 +5,7 @@
#ifndef V8_HEAP_MEMORY_CHUNK_LAYOUT_H_
#define V8_HEAP_MEMORY_CHUNK_LAYOUT_H_
#include "src/heap/base/active-system-pages.h"
#include "src/heap/heap.h"
#include "src/heap/list.h"
#include "src/heap/progress-bar.h"
@ -32,6 +33,8 @@ enum RememberedSetType {
NUMBER_OF_REMEMBERED_SET_TYPES
};
using ActiveSystemPages = ::heap::base::ActiveSystemPages;
class V8_EXPORT_PRIVATE MemoryChunkLayout {
public:
static const int kNumSets = NUMBER_OF_REMEMBERED_SET_TYPES;
@ -68,6 +71,7 @@ class V8_EXPORT_PRIVATE MemoryChunkLayout {
FIELD(Bitmap*, YoungGenerationBitmap),
FIELD(CodeObjectRegistry*, CodeObjectRegistry),
FIELD(PossiblyEmptyBuckets, PossiblyEmptyBuckets),
FIELD(ActiveSystemPages, ActiveSystemPages),
#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
FIELD(ObjectStartBitmap, ObjectStartBitmap),
#endif

View File

@ -6,6 +6,7 @@
#include "src/base/platform/platform.h"
#include "src/base/platform/wrappers.h"
#include "src/common/globals.h"
#include "src/heap/code-object-registry.h"
#include "src/heap/memory-allocator.h"
#include "src/heap/memory-chunk-inl.h"
@ -118,7 +119,8 @@ PageAllocator::Permission DefaultWritableCodePermissions() {
} // namespace
MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
Executability executable) {
Executability executable,
PageSize page_size) {
MemoryChunk* chunk = static_cast<MemoryChunk*>(basic_chunk);
base::AsAtomicPointer::Release_Store(&chunk->slot_set_[OLD_TO_NEW], nullptr);
@ -181,6 +183,15 @@ MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
chunk->possibly_empty_buckets_.Initialize();
if (page_size == PageSize::kRegular) {
chunk->active_system_pages_.Init(MemoryChunkLayout::kMemoryChunkHeaderSize,
MemoryAllocator::GetCommitPageSizeBits(),
chunk->size());
} else {
// We do not track active system pages for large pages.
chunk->active_system_pages_.Clear();
}
// All pages of a shared heap need to be marked with this flag.
if (heap->IsShared()) chunk->SetFlag(IN_SHARED_HEAP);
@ -196,9 +207,8 @@ MemoryChunk* MemoryChunk::Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
}
size_t MemoryChunk::CommittedPhysicalMemory() {
if (!base::OS::HasLazyCommits() || owner_identity() == LO_SPACE)
return size();
return high_water_mark_;
if (!base::OS::HasLazyCommits() || IsLargePage()) return size();
return active_system_pages_.Size(MemoryAllocator::GetCommitPageSizeBits());
}
void MemoryChunk::SetOldGenerationPageFlags(bool is_marking) {

View File

@ -10,6 +10,7 @@
#include "src/base/macros.h"
#include "src/base/platform/mutex.h"
#include "src/common/globals.h"
#include "src/heap/base/active-system-pages.h"
#include "src/heap/basic-memory-chunk.h"
#include "src/heap/heap.h"
#include "src/heap/invalidated-slots.h"
@ -219,7 +220,7 @@ class MemoryChunk : public BasicMemoryChunk {
protected:
static MemoryChunk* Initialize(BasicMemoryChunk* basic_chunk, Heap* heap,
Executability executable);
Executability executable, PageSize page_size);
// Release all memory allocated by the chunk. Should be called when memory
// chunk is about to be freed.
@ -291,6 +292,8 @@ class MemoryChunk : public BasicMemoryChunk {
PossiblyEmptyBuckets possibly_empty_buckets_;
ActiveSystemPages active_system_pages_;
#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
ObjectStartBitmap object_start_bitmap_;
#endif

View File

@ -491,6 +491,10 @@ void NewSpace::UpdateLinearAllocationArea(Address known_top) {
original_limit_.store(limit(), std::memory_order_relaxed);
original_top_.store(top(), std::memory_order_release);
}
Page* page = to_space_.current_page();
page->active_system_pages()->Add(top() - page->address(),
limit() - page->address(),
MemoryAllocator::GetCommitPageSizeBits());
DCHECK_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
UpdateInlineAllocationLimit(0);

View File

@ -4,6 +4,8 @@
#include "src/heap/paged-spaces.h"
#include <atomic>
#include "src/base/optional.h"
#include "src/base/platform/mutex.h"
#include "src/execution/isolate.h"
@ -13,8 +15,10 @@
#include "src/heap/incremental-marking.h"
#include "src/heap/memory-allocator.h"
#include "src/heap/memory-chunk-inl.h"
#include "src/heap/memory-chunk-layout.h"
#include "src/heap/paged-spaces-inl.h"
#include "src/heap/read-only-heap.h"
#include "src/heap/safepoint.h"
#include "src/logging/runtime-call-stats-scope.h"
#include "src/objects/string.h"
#include "src/utils/utils.h"
@ -211,15 +215,42 @@ void PagedSpace::MergeCompactionSpace(CompactionSpace* other) {
}
size_t PagedSpace::CommittedPhysicalMemory() {
if (!base::OS::HasLazyCommits()) return CommittedMemory();
if (!base::OS::HasLazyCommits()) {
DCHECK_EQ(0, committed_physical_memory());
return CommittedMemory();
}
BasicMemoryChunk::UpdateHighWaterMark(allocation_info_->top());
base::MutexGuard guard(mutex());
return committed_physical_memory();
}
void PagedSpace::IncrementCommittedPhysicalMemory(size_t increment_value) {
if (!base::OS::HasLazyCommits() || increment_value == 0) return;
size_t old_value = committed_physical_memory_.fetch_add(
increment_value, std::memory_order_relaxed);
USE(old_value);
DCHECK_LT(old_value, old_value + increment_value);
}
void PagedSpace::DecrementCommittedPhysicalMemory(size_t decrement_value) {
if (!base::OS::HasLazyCommits() || decrement_value == 0) return;
size_t old_value = committed_physical_memory_.fetch_sub(
decrement_value, std::memory_order_relaxed);
USE(old_value);
DCHECK_GT(old_value, old_value - decrement_value);
}
#if DEBUG
void PagedSpace::VerifyCommittedPhysicalMemory() {
heap()->safepoint()->AssertActive();
size_t size = 0;
for (Page* page : *this) {
DCHECK(page->SweepingDone());
size += page->CommittedPhysicalMemory();
}
return size;
// Ensure that the space's counter matches the sum of all page counters.
DCHECK_EQ(size, CommittedPhysicalMemory());
}
#endif // DEBUG
bool PagedSpace::ContainsSlow(Address addr) const {
Page* p = Page::FromAddress(addr);
@ -264,6 +295,7 @@ size_t PagedSpace::AddPage(Page* page) {
ExternalBackingStoreType t = static_cast<ExternalBackingStoreType>(i);
IncrementExternalBackingStoreBytes(t, page->ExternalBackingStoreBytes(t));
}
IncrementCommittedPhysicalMemory(page->CommittedPhysicalMemory());
return RelinkFreeListCategories(page);
}
@ -278,6 +310,7 @@ void PagedSpace::RemovePage(Page* page) {
ExternalBackingStoreType t = static_cast<ExternalBackingStoreType>(i);
DecrementExternalBackingStoreBytes(t, page->ExternalBackingStoreBytes(t));
}
DecrementCommittedPhysicalMemory(page->CommittedPhysicalMemory());
}
void PagedSpace::SetTopAndLimit(Address top, Address limit) {
@ -346,6 +379,7 @@ base::Optional<std::pair<Address, size_t>> PagedSpace::ExpandBackground(
CHECK_LE(size_in_bytes, page->area_size());
Free(page->area_start() + size_in_bytes, page->area_size() - size_in_bytes,
SpaceAccountingMode::kSpaceAccounted);
AddRangeToActiveSystemPages(page, object_start, object_start + size_in_bytes);
return std::make_pair(object_start, size_in_bytes);
}
@ -492,6 +526,7 @@ void PagedSpace::ReleasePage(Page* page) {
}
AccountUncommitted(page->size());
DecrementCommittedPhysicalMemory(page->CommittedPhysicalMemory());
accounting_stats_.DecreaseCapacity(page->area_size());
heap()->memory_allocator()->Free(MemoryAllocator::kConcurrently, page);
}
@ -573,6 +608,7 @@ bool PagedSpace::TryAllocationFromFreeListMain(size_t size_in_bytes,
Free(limit, end - limit, SpaceAccountingMode::kSpaceAccounted);
}
SetLinearAllocationArea(start, limit);
AddRangeToActiveSystemPages(page, start, limit);
return true;
}
@ -693,6 +729,7 @@ PagedSpace::TryAllocationFromFreeListBackground(size_t min_size_in_bytes,
}
Free(limit, end - limit, SpaceAccountingMode::kSpaceAccounted);
}
AddRangeToActiveSystemPages(page, start, limit);
return std::make_pair(start, used_size_in_bytes);
}
@ -1006,6 +1043,28 @@ AllocationResult PagedSpace::AllocateRawSlow(int size_in_bytes,
return result;
}
void PagedSpace::AddRangeToActiveSystemPages(Page* page, Address start,
Address end) {
DCHECK_LE(page->address(), start);
DCHECK_LT(start, end);
DCHECK_LE(end, page->address() + Page::kPageSize);
const size_t added_pages = page->active_system_pages()->Add(
start - page->address(), end - page->address(),
MemoryAllocator::GetCommitPageSizeBits());
IncrementCommittedPhysicalMemory(added_pages *
MemoryAllocator::GetCommitPageSize());
}
void PagedSpace::ReduceActiveSystemPages(
Page* page, ActiveSystemPages active_system_pages) {
const size_t reduced_pages =
page->active_system_pages()->Reduce(active_system_pages);
DecrementCommittedPhysicalMemory(reduced_pages *
MemoryAllocator::GetCommitPageSize());
}
// -----------------------------------------------------------------------------
// MapSpace implementation

View File

@ -5,6 +5,7 @@
#ifndef V8_HEAP_PAGED_SPACES_H_
#define V8_HEAP_PAGED_SPACES_H_
#include <atomic>
#include <memory>
#include <utility>
@ -15,6 +16,7 @@
#include "src/common/globals.h"
#include "src/flags/flags.h"
#include "src/heap/allocation-stats.h"
#include "src/heap/memory-chunk-layout.h"
#include "src/heap/memory-chunk.h"
#include "src/heap/spaces.h"
@ -108,6 +110,13 @@ class V8_EXPORT_PRIVATE PagedSpace
// Approximate amount of physical memory committed for this space.
size_t CommittedPhysicalMemory() override;
#if DEBUG
void VerifyCommittedPhysicalMemory();
#endif // DEBUG
void IncrementCommittedPhysicalMemory(size_t increment_value);
void DecrementCommittedPhysicalMemory(size_t decrement_value);
// Sets the capacity, the available space and the wasted space to zero.
// The stats are rebuilt during sweeping by adding each page to the
// capacity and the size when it is encountered. As free spaces are
@ -327,6 +336,10 @@ class V8_EXPORT_PRIVATE PagedSpace
return &pending_allocation_mutex_;
}
void AddRangeToActiveSystemPages(Page* page, Address start, Address end);
void ReduceActiveSystemPages(Page* page,
ActiveSystemPages active_system_pages);
private:
class ConcurrentAllocationMutex {
public:
@ -423,6 +436,10 @@ class V8_EXPORT_PRIVATE PagedSpace
V8_WARN_UNUSED_RESULT bool TryExpand(int size_in_bytes,
AllocationOrigin origin);
size_t committed_physical_memory() const {
return committed_physical_memory_.load(std::memory_order_relaxed);
}
Executability executable_;
CompactionSpaceKind compaction_space_kind_;
@ -443,6 +460,8 @@ class V8_EXPORT_PRIVATE PagedSpace
// Protects original_top_ and original_limit_.
base::SharedMutex pending_allocation_mutex_;
std::atomic<size_t> committed_physical_memory_{0};
friend class IncrementalMarking;
friend class MarkCompactCollector;

View File

@ -13,6 +13,7 @@
#include "src/base/macros.h"
#include "src/base/sanitizer/msan.h"
#include "src/common/globals.h"
#include "src/heap/base/active-system-pages.h"
#include "src/heap/combined-heap.h"
#include "src/heap/concurrent-marking.h"
#include "src/heap/gc-tracer.h"
@ -22,6 +23,7 @@
#include "src/heap/invalidated-slots-inl.h"
#include "src/heap/large-spaces.h"
#include "src/heap/mark-compact.h"
#include "src/heap/memory-chunk-layout.h"
#include "src/heap/memory-chunk.h"
#include "src/heap/read-only-heap.h"
#include "src/heap/remembered-set.h"

View File

@ -13,11 +13,13 @@
#include "src/common/globals.h"
#include "src/heap/allocation-observer.h"
#include "src/heap/base-space.h"
#include "src/heap/base/active-system-pages.h"
#include "src/heap/basic-memory-chunk.h"
#include "src/heap/free-list.h"
#include "src/heap/heap.h"
#include "src/heap/linear-allocation-area.h"
#include "src/heap/list.h"
#include "src/heap/memory-chunk-layout.h"
#include "src/heap/memory-chunk.h"
#include "src/objects/objects.h"
#include "src/utils/allocation.h"
@ -307,6 +309,8 @@ class Page : public MemoryChunk {
void MoveOldToNewRememberedSetForSweeping();
void MergeOldToNewRememberedSets();
ActiveSystemPages* active_system_pages() { return &active_system_pages_; }
private:
friend class MemoryAllocator;
};

View File

@ -6,6 +6,7 @@
#include "src/common/globals.h"
#include "src/execution/vm-state-inl.h"
#include "src/heap/base/active-system-pages.h"
#include "src/heap/code-object-registry.h"
#include "src/heap/free-list-inl.h"
#include "src/heap/gc-tracer.h"
@ -335,6 +336,15 @@ int Sweeper::RawSweep(
CodeObjectRegistry* code_object_registry = p->GetCodeObjectRegistry();
if (code_object_registry) code_object_registry->Clear();
base::Optional<ActiveSystemPages> active_system_pages_after_sweeping;
if (should_reduce_memory_) {
// Only decrement counter when we discard unused system pages.
active_system_pages_after_sweeping = ActiveSystemPages();
active_system_pages_after_sweeping->Init(
MemoryChunkLayout::kMemoryChunkHeaderSize,
MemoryAllocator::GetCommitPageSizeBits(), Page::kPageSize);
}
// Phase 2: Free the non-live memory and clean-up the regular remembered set
// entires.
@ -389,6 +399,12 @@ int Sweeper::RawSweep(
live_bytes += size;
free_start = free_end + size;
if (active_system_pages_after_sweeping) {
active_system_pages_after_sweeping->Add(
free_end - p->address(), free_start - p->address(),
MemoryAllocator::GetCommitPageSizeBits());
}
#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
p->object_start_bitmap()->SetBit(object.address());
#endif
@ -411,6 +427,13 @@ int Sweeper::RawSweep(
CleanupInvalidTypedSlotsOfFreeRanges(p, free_ranges_map);
ClearMarkBitsAndHandleLivenessStatistics(p, live_bytes, free_list_mode);
if (active_system_pages_after_sweeping) {
// Decrement accounted memory for discarded memory.
PagedSpace* paged_space = static_cast<PagedSpace*>(p->owner());
paged_space->ReduceActiveSystemPages(p,
*active_system_pages_after_sweeping);
}
if (code_object_registry) code_object_registry->Finalize();
p->set_concurrent_sweeping_state(Page::ConcurrentSweepingState::kDone);
if (free_list_mode == IGNORE_FREE_LIST) return 0;

View File

@ -114,7 +114,8 @@ class V8_NODISCARD TestCodePageAllocatorScope {
static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
v8::PageAllocator* code_page_allocator,
size_t reserve_area_size, size_t commit_area_size,
Executability executable, Space* space) {
Executability executable, PageSize page_size,
Space* space) {
TestMemoryAllocatorScope test_allocator_scope(isolate, heap->MaxReserved());
MemoryAllocator* memory_allocator = test_allocator_scope.allocator();
TestCodePageAllocatorScope test_code_page_allocator_scope(
@ -129,7 +130,7 @@ static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
(executable == EXECUTABLE) ? MemoryChunkLayout::CodePageGuardSize() : 0;
MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(
reserve_area_size, commit_area_size, executable, space);
reserve_area_size, commit_area_size, executable, page_size, space);
size_t reserved_size =
((executable == EXECUTABLE))
? allocatable_memory_area_offset +
@ -179,11 +180,12 @@ TEST(MemoryChunk) {
base::PageInitializationMode::kAllocatedPagesCanBeUninitialized);
VerifyMemoryChunk(isolate, heap, &code_page_allocator, reserve_area_size,
initial_commit_area_size, EXECUTABLE, heap->code_space());
initial_commit_area_size, EXECUTABLE, PageSize::kLarge,
heap->code_space());
VerifyMemoryChunk(isolate, heap, &code_page_allocator, reserve_area_size,
initial_commit_area_size, NOT_EXECUTABLE,
heap->old_space());
PageSize::kLarge, heap->old_space());
}
}

View File

@ -42,7 +42,10 @@ v8_executable("v8_heap_base_unittests") {
v8_source_set("v8_heap_base_unittests_sources") {
testonly = true
sources = [ "heap/base/worklist-unittest.cc" ]
sources = [
"heap/base/active-system-pages-unittest.cc",
"heap/base/worklist-unittest.cc",
]
configs = [
"../..:external_config",

View File

@ -0,0 +1,81 @@
// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/heap/base/active-system-pages.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace heap {
namespace base {
TEST(ActiveSystemPagesTest, Add) {
ActiveSystemPages pages;
const size_t kPageSizeBits = 0;
EXPECT_EQ(pages.Add(0, 1, kPageSizeBits), size_t{1});
EXPECT_EQ(pages.Add(1, 2, kPageSizeBits), size_t{1});
EXPECT_EQ(pages.Add(63, 64, kPageSizeBits), size_t{1});
EXPECT_EQ(pages.Size(kPageSizeBits), size_t{3});
// Try to add page a second time.
EXPECT_EQ(pages.Add(0, 2, kPageSizeBits), size_t{0});
}
TEST(ActiveSystemPagesTest, AddUnalignedRange) {
ActiveSystemPages pages;
const size_t kPageSizeBits = 12;
const size_t kPageSize = size_t{1} << kPageSizeBits;
const size_t kWordSize = 8;
EXPECT_EQ(pages.Add(0, kPageSize + kWordSize, kPageSizeBits), size_t{2});
EXPECT_EQ(pages.Add(3 * kPageSize - kWordSize, 3 * kPageSize, kPageSizeBits),
size_t{1});
EXPECT_EQ(pages.Add(kPageSize + kWordSize, 3 * kPageSize - kWordSize,
kPageSizeBits),
size_t{0});
EXPECT_EQ(pages.Size(kPageSizeBits), size_t{3} * kPageSize);
}
TEST(ActiveSystemPagesTest, AddFullBitset) {
ActiveSystemPages pages;
const size_t kPageSizeBits = 0;
EXPECT_EQ(pages.Add(0, 64, kPageSizeBits), size_t{64});
EXPECT_EQ(pages.Add(0, 64, kPageSizeBits), size_t{0});
EXPECT_EQ(pages.Size(kPageSizeBits), size_t{64});
}
TEST(ActiveSystemPagesTest, Reduce) {
ActiveSystemPages original;
const size_t kPageSizeBits = 0;
EXPECT_EQ(original.Add(0, 3, kPageSizeBits), size_t{3});
ActiveSystemPages updated;
EXPECT_EQ(updated.Add(1, 3, kPageSizeBits), size_t{2});
EXPECT_EQ(original.Reduce(updated), size_t{1});
}
TEST(ActiveSystemPagesTest, ReduceFullBitset) {
ActiveSystemPages original;
const size_t kPageSizeBits = 0;
EXPECT_EQ(original.Add(0, 64, kPageSizeBits), size_t{64});
ActiveSystemPages updated;
EXPECT_EQ(updated.Add(63, 64, kPageSizeBits), size_t{1});
EXPECT_EQ(original.Reduce(updated), size_t{63});
}
TEST(ActiveSystemPagesTest, Clear) {
ActiveSystemPages pages;
const size_t kPageSizeBits = 0;
EXPECT_EQ(pages.Add(0, 64, kPageSizeBits), size_t{64});
EXPECT_EQ(pages.Clear(), size_t{64});
EXPECT_EQ(pages.Size(kPageSizeBits), size_t{0});
EXPECT_EQ(pages.Add(0, 2, kPageSizeBits), size_t{2});
EXPECT_EQ(pages.Clear(), size_t{2});
EXPECT_EQ(pages.Size(kPageSizeBits), size_t{0});
}
} // namespace base
} // namespace heap

View File

@ -272,287 +272,287 @@ INSTANCE_TYPES = {
# List of known V8 maps.
KNOWN_MAPS = {
("read_only_space", 0x02149): (249, "MetaMap"),
("read_only_space", 0x02171): (131, "NullMap"),
("read_only_space", 0x02199): (234, "StrongDescriptorArrayMap"),
("read_only_space", 0x021c1): (263, "WeakArrayListMap"),
("read_only_space", 0x02205): (157, "EnumCacheMap"),
("read_only_space", 0x02239): (178, "FixedArrayMap"),
("read_only_space", 0x02285): (8, "OneByteInternalizedStringMap"),
("read_only_space", 0x022d1): (246, "FreeSpaceMap"),
("read_only_space", 0x022f9): (245, "OnePointerFillerMap"),
("read_only_space", 0x02321): (245, "TwoPointerFillerMap"),
("read_only_space", 0x02349): (131, "UninitializedMap"),
("read_only_space", 0x023c1): (131, "UndefinedMap"),
("read_only_space", 0x02405): (130, "HeapNumberMap"),
("read_only_space", 0x02439): (131, "TheHoleMap"),
("read_only_space", 0x02499): (131, "BooleanMap"),
("read_only_space", 0x0253d): (193, "ByteArrayMap"),
("read_only_space", 0x02565): (178, "FixedCOWArrayMap"),
("read_only_space", 0x0258d): (179, "HashTableMap"),
("read_only_space", 0x025b5): (128, "SymbolMap"),
("read_only_space", 0x025dd): (40, "OneByteStringMap"),
("read_only_space", 0x02605): (255, "ScopeInfoMap"),
("read_only_space", 0x0262d): (256, "SharedFunctionInfoMap"),
("read_only_space", 0x02655): (239, "CodeMap"),
("read_only_space", 0x0267d): (203, "CellMap"),
("read_only_space", 0x026a5): (254, "GlobalPropertyCellMap"),
("read_only_space", 0x026cd): (204, "ForeignMap"),
("read_only_space", 0x026f5): (238, "TransitionArrayMap"),
("read_only_space", 0x0271d): (45, "ThinOneByteStringMap"),
("read_only_space", 0x02745): (244, "FeedbackVectorMap"),
("read_only_space", 0x0277d): (131, "ArgumentsMarkerMap"),
("read_only_space", 0x027dd): (131, "ExceptionMap"),
("read_only_space", 0x02839): (131, "TerminationExceptionMap"),
("read_only_space", 0x028a1): (131, "OptimizedOutMap"),
("read_only_space", 0x02901): (131, "StaleRegisterMap"),
("read_only_space", 0x02961): (192, "ScriptContextTableMap"),
("read_only_space", 0x02989): (190, "ClosureFeedbackCellArrayMap"),
("read_only_space", 0x029b1): (243, "FeedbackMetadataArrayMap"),
("read_only_space", 0x029d9): (178, "ArrayListMap"),
("read_only_space", 0x02a01): (129, "BigIntMap"),
("read_only_space", 0x02a29): (191, "ObjectBoilerplateDescriptionMap"),
("read_only_space", 0x02a51): (194, "BytecodeArrayMap"),
("read_only_space", 0x02a79): (240, "CodeDataContainerMap"),
("read_only_space", 0x02aa1): (241, "CoverageInfoMap"),
("read_only_space", 0x02ac9): (195, "FixedDoubleArrayMap"),
("read_only_space", 0x02af1): (181, "GlobalDictionaryMap"),
("read_only_space", 0x02b19): (159, "ManyClosuresCellMap"),
("read_only_space", 0x02b41): (250, "MegaDomHandlerMap"),
("read_only_space", 0x02b69): (178, "ModuleInfoMap"),
("read_only_space", 0x02b91): (182, "NameDictionaryMap"),
("read_only_space", 0x02bb9): (159, "NoClosuresCellMap"),
("read_only_space", 0x02be1): (184, "NumberDictionaryMap"),
("read_only_space", 0x02c09): (159, "OneClosureCellMap"),
("read_only_space", 0x02c31): (185, "OrderedHashMapMap"),
("read_only_space", 0x02c59): (186, "OrderedHashSetMap"),
("read_only_space", 0x02c81): (183, "NameToIndexHashTableMap"),
("read_only_space", 0x02ca9): (188, "RegisteredSymbolTableMap"),
("read_only_space", 0x02cd1): (187, "OrderedNameDictionaryMap"),
("read_only_space", 0x02cf9): (252, "PreparseDataMap"),
("read_only_space", 0x02d21): (253, "PropertyArrayMap"),
("read_only_space", 0x02d49): (153, "SideEffectCallHandlerInfoMap"),
("read_only_space", 0x02d71): (153, "SideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02d99): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02dc1): (189, "SimpleNumberDictionaryMap"),
("read_only_space", 0x02de9): (228, "SmallOrderedHashMapMap"),
("read_only_space", 0x02e11): (229, "SmallOrderedHashSetMap"),
("read_only_space", 0x02e39): (230, "SmallOrderedNameDictionaryMap"),
("read_only_space", 0x02e61): (235, "SourceTextModuleMap"),
("read_only_space", 0x02e89): (260, "SwissNameDictionaryMap"),
("read_only_space", 0x02eb1): (236, "SyntheticModuleMap"),
("read_only_space", 0x02ed9): (261, "WasmApiFunctionRefMap"),
("read_only_space", 0x02f01): (222, "WasmCapiFunctionDataMap"),
("read_only_space", 0x02f29): (223, "WasmExportedFunctionDataMap"),
("read_only_space", 0x02f51): (205, "WasmInternalFunctionMap"),
("read_only_space", 0x02f79): (224, "WasmJSFunctionDataMap"),
("read_only_space", 0x02fa1): (262, "WasmOnFulfilledDataMap"),
("read_only_space", 0x02fc9): (206, "WasmTypeInfoMap"),
("read_only_space", 0x02ff1): (237, "WeakFixedArrayMap"),
("read_only_space", 0x03019): (180, "EphemeronHashTableMap"),
("read_only_space", 0x03041): (242, "EmbedderDataArrayMap"),
("read_only_space", 0x03069): (264, "WeakCellMap"),
("read_only_space", 0x03091): (32, "StringMap"),
("read_only_space", 0x030b9): (41, "ConsOneByteStringMap"),
("read_only_space", 0x030e1): (33, "ConsStringMap"),
("read_only_space", 0x03109): (37, "ThinStringMap"),
("read_only_space", 0x03131): (35, "SlicedStringMap"),
("read_only_space", 0x03159): (43, "SlicedOneByteStringMap"),
("read_only_space", 0x03181): (34, "ExternalStringMap"),
("read_only_space", 0x031a9): (42, "ExternalOneByteStringMap"),
("read_only_space", 0x031d1): (50, "UncachedExternalStringMap"),
("read_only_space", 0x031f9): (0, "InternalizedStringMap"),
("read_only_space", 0x03221): (2, "ExternalInternalizedStringMap"),
("read_only_space", 0x03249): (10, "ExternalOneByteInternalizedStringMap"),
("read_only_space", 0x03271): (18, "UncachedExternalInternalizedStringMap"),
("read_only_space", 0x03299): (26, "UncachedExternalOneByteInternalizedStringMap"),
("read_only_space", 0x032c1): (58, "UncachedExternalOneByteStringMap"),
("read_only_space", 0x032e9): (104, "SharedOneByteStringMap"),
("read_only_space", 0x03311): (96, "SharedStringMap"),
("read_only_space", 0x03339): (109, "SharedThinOneByteStringMap"),
("read_only_space", 0x03361): (101, "SharedThinStringMap"),
("read_only_space", 0x03389): (96, "TwoByteSeqStringMigrationSentinelMap"),
("read_only_space", 0x033b1): (104, "OneByteSeqStringMigrationSentinelMap"),
("read_only_space", 0x033d9): (131, "SelfReferenceMarkerMap"),
("read_only_space", 0x03401): (131, "BasicBlockCountersMarkerMap"),
("read_only_space", 0x03445): (147, "ArrayBoilerplateDescriptionMap"),
("read_only_space", 0x03545): (161, "InterceptorInfoMap"),
("read_only_space", 0x06015): (132, "PromiseFulfillReactionJobTaskMap"),
("read_only_space", 0x0603d): (133, "PromiseRejectReactionJobTaskMap"),
("read_only_space", 0x06065): (134, "CallableTaskMap"),
("read_only_space", 0x0608d): (135, "CallbackTaskMap"),
("read_only_space", 0x060b5): (136, "PromiseResolveThenableJobTaskMap"),
("read_only_space", 0x060dd): (139, "FunctionTemplateInfoMap"),
("read_only_space", 0x06105): (140, "ObjectTemplateInfoMap"),
("read_only_space", 0x0612d): (141, "AccessCheckInfoMap"),
("read_only_space", 0x06155): (142, "AccessorInfoMap"),
("read_only_space", 0x0617d): (143, "AccessorPairMap"),
("read_only_space", 0x061a5): (144, "AliasedArgumentsEntryMap"),
("read_only_space", 0x061cd): (145, "AllocationMementoMap"),
("read_only_space", 0x061f5): (148, "AsmWasmDataMap"),
("read_only_space", 0x0621d): (149, "AsyncGeneratorRequestMap"),
("read_only_space", 0x06245): (150, "BreakPointMap"),
("read_only_space", 0x0626d): (151, "BreakPointInfoMap"),
("read_only_space", 0x06295): (152, "CachedTemplateObjectMap"),
("read_only_space", 0x062bd): (154, "CallSiteInfoMap"),
("read_only_space", 0x062e5): (155, "ClassPositionsMap"),
("read_only_space", 0x0630d): (156, "DebugInfoMap"),
("read_only_space", 0x06335): (158, "ErrorStackDataMap"),
("read_only_space", 0x0635d): (160, "FunctionTemplateRareDataMap"),
("read_only_space", 0x06385): (162, "InterpreterDataMap"),
("read_only_space", 0x063ad): (163, "ModuleRequestMap"),
("read_only_space", 0x063d5): (164, "PromiseCapabilityMap"),
("read_only_space", 0x063fd): (165, "PromiseReactionMap"),
("read_only_space", 0x06425): (166, "PropertyDescriptorObjectMap"),
("read_only_space", 0x0644d): (167, "PrototypeInfoMap"),
("read_only_space", 0x06475): (168, "RegExpBoilerplateDescriptionMap"),
("read_only_space", 0x0649d): (169, "ScriptMap"),
("read_only_space", 0x064c5): (170, "ScriptOrModuleMap"),
("read_only_space", 0x064ed): (171, "SourceTextModuleInfoEntryMap"),
("read_only_space", 0x06515): (172, "StackFrameInfoMap"),
("read_only_space", 0x0653d): (173, "TemplateObjectDescriptionMap"),
("read_only_space", 0x06565): (174, "Tuple2Map"),
("read_only_space", 0x0658d): (175, "WasmContinuationObjectMap"),
("read_only_space", 0x065b5): (176, "WasmExceptionTagMap"),
("read_only_space", 0x065dd): (177, "WasmIndirectFunctionTableMap"),
("read_only_space", 0x06605): (197, "SloppyArgumentsElementsMap"),
("read_only_space", 0x0662d): (233, "DescriptorArrayMap"),
("read_only_space", 0x06655): (219, "UncompiledDataWithoutPreparseDataMap"),
("read_only_space", 0x0667d): (217, "UncompiledDataWithPreparseDataMap"),
("read_only_space", 0x066a5): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
("read_only_space", 0x066cd): (218, "UncompiledDataWithPreparseDataAndJobMap"),
("read_only_space", 0x066f5): (251, "OnHeapBasicBlockProfilerDataMap"),
("read_only_space", 0x0671d): (198, "TurbofanBitsetTypeMap"),
("read_only_space", 0x06745): (202, "TurbofanUnionTypeMap"),
("read_only_space", 0x0676d): (201, "TurbofanRangeTypeMap"),
("read_only_space", 0x06795): (199, "TurbofanHeapConstantTypeMap"),
("read_only_space", 0x067bd): (200, "TurbofanOtherNumberConstantTypeMap"),
("read_only_space", 0x067e5): (247, "InternalClassMap"),
("read_only_space", 0x0680d): (258, "SmiPairMap"),
("read_only_space", 0x06835): (257, "SmiBoxMap"),
("read_only_space", 0x0685d): (225, "ExportedSubClassBaseMap"),
("read_only_space", 0x06885): (226, "ExportedSubClassMap"),
("read_only_space", 0x068ad): (231, "AbstractInternalClassSubclass1Map"),
("read_only_space", 0x068d5): (232, "AbstractInternalClassSubclass2Map"),
("read_only_space", 0x068fd): (196, "InternalClassWithSmiElementsMap"),
("read_only_space", 0x06925): (248, "InternalClassWithStructElementsMap"),
("read_only_space", 0x0694d): (227, "ExportedSubClass2Map"),
("read_only_space", 0x06975): (259, "SortStateMap"),
("read_only_space", 0x0699d): (146, "AllocationSiteWithWeakNextMap"),
("read_only_space", 0x069c5): (146, "AllocationSiteWithoutWeakNextMap"),
("read_only_space", 0x069ed): (137, "LoadHandler1Map"),
("read_only_space", 0x06a15): (137, "LoadHandler2Map"),
("read_only_space", 0x06a3d): (137, "LoadHandler3Map"),
("read_only_space", 0x06a65): (138, "StoreHandler0Map"),
("read_only_space", 0x06a8d): (138, "StoreHandler1Map"),
("read_only_space", 0x06ab5): (138, "StoreHandler2Map"),
("read_only_space", 0x06add): (138, "StoreHandler3Map"),
("map_space", 0x02149): (1057, "ExternalMap"),
("map_space", 0x02171): (2115, "JSMessageObjectMap"),
("read_only_space", 0x02151): (249, "MetaMap"),
("read_only_space", 0x02179): (131, "NullMap"),
("read_only_space", 0x021a1): (234, "StrongDescriptorArrayMap"),
("read_only_space", 0x021c9): (263, "WeakArrayListMap"),
("read_only_space", 0x0220d): (157, "EnumCacheMap"),
("read_only_space", 0x02241): (178, "FixedArrayMap"),
("read_only_space", 0x0228d): (8, "OneByteInternalizedStringMap"),
("read_only_space", 0x022d9): (246, "FreeSpaceMap"),
("read_only_space", 0x02301): (245, "OnePointerFillerMap"),
("read_only_space", 0x02329): (245, "TwoPointerFillerMap"),
("read_only_space", 0x02351): (131, "UninitializedMap"),
("read_only_space", 0x023c9): (131, "UndefinedMap"),
("read_only_space", 0x0240d): (130, "HeapNumberMap"),
("read_only_space", 0x02441): (131, "TheHoleMap"),
("read_only_space", 0x024a1): (131, "BooleanMap"),
("read_only_space", 0x02545): (193, "ByteArrayMap"),
("read_only_space", 0x0256d): (178, "FixedCOWArrayMap"),
("read_only_space", 0x02595): (179, "HashTableMap"),
("read_only_space", 0x025bd): (128, "SymbolMap"),
("read_only_space", 0x025e5): (40, "OneByteStringMap"),
("read_only_space", 0x0260d): (255, "ScopeInfoMap"),
("read_only_space", 0x02635): (256, "SharedFunctionInfoMap"),
("read_only_space", 0x0265d): (239, "CodeMap"),
("read_only_space", 0x02685): (203, "CellMap"),
("read_only_space", 0x026ad): (254, "GlobalPropertyCellMap"),
("read_only_space", 0x026d5): (204, "ForeignMap"),
("read_only_space", 0x026fd): (238, "TransitionArrayMap"),
("read_only_space", 0x02725): (45, "ThinOneByteStringMap"),
("read_only_space", 0x0274d): (244, "FeedbackVectorMap"),
("read_only_space", 0x02785): (131, "ArgumentsMarkerMap"),
("read_only_space", 0x027e5): (131, "ExceptionMap"),
("read_only_space", 0x02841): (131, "TerminationExceptionMap"),
("read_only_space", 0x028a9): (131, "OptimizedOutMap"),
("read_only_space", 0x02909): (131, "StaleRegisterMap"),
("read_only_space", 0x02969): (192, "ScriptContextTableMap"),
("read_only_space", 0x02991): (190, "ClosureFeedbackCellArrayMap"),
("read_only_space", 0x029b9): (243, "FeedbackMetadataArrayMap"),
("read_only_space", 0x029e1): (178, "ArrayListMap"),
("read_only_space", 0x02a09): (129, "BigIntMap"),
("read_only_space", 0x02a31): (191, "ObjectBoilerplateDescriptionMap"),
("read_only_space", 0x02a59): (194, "BytecodeArrayMap"),
("read_only_space", 0x02a81): (240, "CodeDataContainerMap"),
("read_only_space", 0x02aa9): (241, "CoverageInfoMap"),
("read_only_space", 0x02ad1): (195, "FixedDoubleArrayMap"),
("read_only_space", 0x02af9): (181, "GlobalDictionaryMap"),
("read_only_space", 0x02b21): (159, "ManyClosuresCellMap"),
("read_only_space", 0x02b49): (250, "MegaDomHandlerMap"),
("read_only_space", 0x02b71): (178, "ModuleInfoMap"),
("read_only_space", 0x02b99): (182, "NameDictionaryMap"),
("read_only_space", 0x02bc1): (159, "NoClosuresCellMap"),
("read_only_space", 0x02be9): (184, "NumberDictionaryMap"),
("read_only_space", 0x02c11): (159, "OneClosureCellMap"),
("read_only_space", 0x02c39): (185, "OrderedHashMapMap"),
("read_only_space", 0x02c61): (186, "OrderedHashSetMap"),
("read_only_space", 0x02c89): (183, "NameToIndexHashTableMap"),
("read_only_space", 0x02cb1): (188, "RegisteredSymbolTableMap"),
("read_only_space", 0x02cd9): (187, "OrderedNameDictionaryMap"),
("read_only_space", 0x02d01): (252, "PreparseDataMap"),
("read_only_space", 0x02d29): (253, "PropertyArrayMap"),
("read_only_space", 0x02d51): (153, "SideEffectCallHandlerInfoMap"),
("read_only_space", 0x02d79): (153, "SideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02da1): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02dc9): (189, "SimpleNumberDictionaryMap"),
("read_only_space", 0x02df1): (228, "SmallOrderedHashMapMap"),
("read_only_space", 0x02e19): (229, "SmallOrderedHashSetMap"),
("read_only_space", 0x02e41): (230, "SmallOrderedNameDictionaryMap"),
("read_only_space", 0x02e69): (235, "SourceTextModuleMap"),
("read_only_space", 0x02e91): (260, "SwissNameDictionaryMap"),
("read_only_space", 0x02eb9): (236, "SyntheticModuleMap"),
("read_only_space", 0x02ee1): (261, "WasmApiFunctionRefMap"),
("read_only_space", 0x02f09): (222, "WasmCapiFunctionDataMap"),
("read_only_space", 0x02f31): (223, "WasmExportedFunctionDataMap"),
("read_only_space", 0x02f59): (205, "WasmInternalFunctionMap"),
("read_only_space", 0x02f81): (224, "WasmJSFunctionDataMap"),
("read_only_space", 0x02fa9): (262, "WasmOnFulfilledDataMap"),
("read_only_space", 0x02fd1): (206, "WasmTypeInfoMap"),
("read_only_space", 0x02ff9): (237, "WeakFixedArrayMap"),
("read_only_space", 0x03021): (180, "EphemeronHashTableMap"),
("read_only_space", 0x03049): (242, "EmbedderDataArrayMap"),
("read_only_space", 0x03071): (264, "WeakCellMap"),
("read_only_space", 0x03099): (32, "StringMap"),
("read_only_space", 0x030c1): (41, "ConsOneByteStringMap"),
("read_only_space", 0x030e9): (33, "ConsStringMap"),
("read_only_space", 0x03111): (37, "ThinStringMap"),
("read_only_space", 0x03139): (35, "SlicedStringMap"),
("read_only_space", 0x03161): (43, "SlicedOneByteStringMap"),
("read_only_space", 0x03189): (34, "ExternalStringMap"),
("read_only_space", 0x031b1): (42, "ExternalOneByteStringMap"),
("read_only_space", 0x031d9): (50, "UncachedExternalStringMap"),
("read_only_space", 0x03201): (0, "InternalizedStringMap"),
("read_only_space", 0x03229): (2, "ExternalInternalizedStringMap"),
("read_only_space", 0x03251): (10, "ExternalOneByteInternalizedStringMap"),
("read_only_space", 0x03279): (18, "UncachedExternalInternalizedStringMap"),
("read_only_space", 0x032a1): (26, "UncachedExternalOneByteInternalizedStringMap"),
("read_only_space", 0x032c9): (58, "UncachedExternalOneByteStringMap"),
("read_only_space", 0x032f1): (104, "SharedOneByteStringMap"),
("read_only_space", 0x03319): (96, "SharedStringMap"),
("read_only_space", 0x03341): (109, "SharedThinOneByteStringMap"),
("read_only_space", 0x03369): (101, "SharedThinStringMap"),
("read_only_space", 0x03391): (96, "TwoByteSeqStringMigrationSentinelMap"),
("read_only_space", 0x033b9): (104, "OneByteSeqStringMigrationSentinelMap"),
("read_only_space", 0x033e1): (131, "SelfReferenceMarkerMap"),
("read_only_space", 0x03409): (131, "BasicBlockCountersMarkerMap"),
("read_only_space", 0x0344d): (147, "ArrayBoilerplateDescriptionMap"),
("read_only_space", 0x0354d): (161, "InterceptorInfoMap"),
("read_only_space", 0x0601d): (132, "PromiseFulfillReactionJobTaskMap"),
("read_only_space", 0x06045): (133, "PromiseRejectReactionJobTaskMap"),
("read_only_space", 0x0606d): (134, "CallableTaskMap"),
("read_only_space", 0x06095): (135, "CallbackTaskMap"),
("read_only_space", 0x060bd): (136, "PromiseResolveThenableJobTaskMap"),
("read_only_space", 0x060e5): (139, "FunctionTemplateInfoMap"),
("read_only_space", 0x0610d): (140, "ObjectTemplateInfoMap"),
("read_only_space", 0x06135): (141, "AccessCheckInfoMap"),
("read_only_space", 0x0615d): (142, "AccessorInfoMap"),
("read_only_space", 0x06185): (143, "AccessorPairMap"),
("read_only_space", 0x061ad): (144, "AliasedArgumentsEntryMap"),
("read_only_space", 0x061d5): (145, "AllocationMementoMap"),
("read_only_space", 0x061fd): (148, "AsmWasmDataMap"),
("read_only_space", 0x06225): (149, "AsyncGeneratorRequestMap"),
("read_only_space", 0x0624d): (150, "BreakPointMap"),
("read_only_space", 0x06275): (151, "BreakPointInfoMap"),
("read_only_space", 0x0629d): (152, "CachedTemplateObjectMap"),
("read_only_space", 0x062c5): (154, "CallSiteInfoMap"),
("read_only_space", 0x062ed): (155, "ClassPositionsMap"),
("read_only_space", 0x06315): (156, "DebugInfoMap"),
("read_only_space", 0x0633d): (158, "ErrorStackDataMap"),
("read_only_space", 0x06365): (160, "FunctionTemplateRareDataMap"),
("read_only_space", 0x0638d): (162, "InterpreterDataMap"),
("read_only_space", 0x063b5): (163, "ModuleRequestMap"),
("read_only_space", 0x063dd): (164, "PromiseCapabilityMap"),
("read_only_space", 0x06405): (165, "PromiseReactionMap"),
("read_only_space", 0x0642d): (166, "PropertyDescriptorObjectMap"),
("read_only_space", 0x06455): (167, "PrototypeInfoMap"),
("read_only_space", 0x0647d): (168, "RegExpBoilerplateDescriptionMap"),
("read_only_space", 0x064a5): (169, "ScriptMap"),
("read_only_space", 0x064cd): (170, "ScriptOrModuleMap"),
("read_only_space", 0x064f5): (171, "SourceTextModuleInfoEntryMap"),
("read_only_space", 0x0651d): (172, "StackFrameInfoMap"),
("read_only_space", 0x06545): (173, "TemplateObjectDescriptionMap"),
("read_only_space", 0x0656d): (174, "Tuple2Map"),
("read_only_space", 0x06595): (175, "WasmContinuationObjectMap"),
("read_only_space", 0x065bd): (176, "WasmExceptionTagMap"),
("read_only_space", 0x065e5): (177, "WasmIndirectFunctionTableMap"),
("read_only_space", 0x0660d): (197, "SloppyArgumentsElementsMap"),
("read_only_space", 0x06635): (233, "DescriptorArrayMap"),
("read_only_space", 0x0665d): (219, "UncompiledDataWithoutPreparseDataMap"),
("read_only_space", 0x06685): (217, "UncompiledDataWithPreparseDataMap"),
("read_only_space", 0x066ad): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
("read_only_space", 0x066d5): (218, "UncompiledDataWithPreparseDataAndJobMap"),
("read_only_space", 0x066fd): (251, "OnHeapBasicBlockProfilerDataMap"),
("read_only_space", 0x06725): (198, "TurbofanBitsetTypeMap"),
("read_only_space", 0x0674d): (202, "TurbofanUnionTypeMap"),
("read_only_space", 0x06775): (201, "TurbofanRangeTypeMap"),
("read_only_space", 0x0679d): (199, "TurbofanHeapConstantTypeMap"),
("read_only_space", 0x067c5): (200, "TurbofanOtherNumberConstantTypeMap"),
("read_only_space", 0x067ed): (247, "InternalClassMap"),
("read_only_space", 0x06815): (258, "SmiPairMap"),
("read_only_space", 0x0683d): (257, "SmiBoxMap"),
("read_only_space", 0x06865): (225, "ExportedSubClassBaseMap"),
("read_only_space", 0x0688d): (226, "ExportedSubClassMap"),
("read_only_space", 0x068b5): (231, "AbstractInternalClassSubclass1Map"),
("read_only_space", 0x068dd): (232, "AbstractInternalClassSubclass2Map"),
("read_only_space", 0x06905): (196, "InternalClassWithSmiElementsMap"),
("read_only_space", 0x0692d): (248, "InternalClassWithStructElementsMap"),
("read_only_space", 0x06955): (227, "ExportedSubClass2Map"),
("read_only_space", 0x0697d): (259, "SortStateMap"),
("read_only_space", 0x069a5): (146, "AllocationSiteWithWeakNextMap"),
("read_only_space", 0x069cd): (146, "AllocationSiteWithoutWeakNextMap"),
("read_only_space", 0x069f5): (137, "LoadHandler1Map"),
("read_only_space", 0x06a1d): (137, "LoadHandler2Map"),
("read_only_space", 0x06a45): (137, "LoadHandler3Map"),
("read_only_space", 0x06a6d): (138, "StoreHandler0Map"),
("read_only_space", 0x06a95): (138, "StoreHandler1Map"),
("read_only_space", 0x06abd): (138, "StoreHandler2Map"),
("read_only_space", 0x06ae5): (138, "StoreHandler3Map"),
("map_space", 0x02151): (1057, "ExternalMap"),
("map_space", 0x02179): (2115, "JSMessageObjectMap"),
}
# List of known V8 objects.
KNOWN_OBJECTS = {
("read_only_space", 0x021e9): "EmptyWeakArrayList",
("read_only_space", 0x021f5): "EmptyDescriptorArray",
("read_only_space", 0x0222d): "EmptyEnumCache",
("read_only_space", 0x02261): "EmptyFixedArray",
("read_only_space", 0x02269): "NullValue",
("read_only_space", 0x02371): "UninitializedValue",
("read_only_space", 0x023e9): "UndefinedValue",
("read_only_space", 0x0242d): "NanValue",
("read_only_space", 0x02461): "TheHoleValue",
("read_only_space", 0x0248d): "HoleNanValue",
("read_only_space", 0x024c1): "TrueValue",
("read_only_space", 0x02501): "FalseValue",
("read_only_space", 0x02531): "empty_string",
("read_only_space", 0x0276d): "EmptyScopeInfo",
("read_only_space", 0x027a5): "ArgumentsMarker",
("read_only_space", 0x02805): "Exception",
("read_only_space", 0x02861): "TerminationException",
("read_only_space", 0x028c9): "OptimizedOut",
("read_only_space", 0x02929): "StaleRegister",
("read_only_space", 0x03429): "EmptyPropertyArray",
("read_only_space", 0x03431): "EmptyByteArray",
("read_only_space", 0x03439): "EmptyObjectBoilerplateDescription",
("read_only_space", 0x0346d): "EmptyArrayBoilerplateDescription",
("read_only_space", 0x03479): "EmptyClosureFeedbackCellArray",
("read_only_space", 0x03481): "EmptySlowElementDictionary",
("read_only_space", 0x034a5): "EmptyOrderedHashMap",
("read_only_space", 0x034b9): "EmptyOrderedHashSet",
("read_only_space", 0x034cd): "EmptyFeedbackMetadata",
("read_only_space", 0x034d9): "EmptyPropertyDictionary",
("read_only_space", 0x03501): "EmptyOrderedPropertyDictionary",
("read_only_space", 0x03519): "EmptySwissPropertyDictionary",
("read_only_space", 0x0356d): "NoOpInterceptorInfo",
("read_only_space", 0x03595): "EmptyArrayList",
("read_only_space", 0x035a1): "EmptyWeakFixedArray",
("read_only_space", 0x035a9): "InfinityValue",
("read_only_space", 0x035b5): "MinusZeroValue",
("read_only_space", 0x035c1): "MinusInfinityValue",
("read_only_space", 0x035cd): "SelfReferenceMarker",
("read_only_space", 0x0360d): "BasicBlockCountersMarker",
("read_only_space", 0x03651): "OffHeapTrampolineRelocationInfo",
("read_only_space", 0x0365d): "GlobalThisBindingScopeInfo",
("read_only_space", 0x0368d): "EmptyFunctionScopeInfo",
("read_only_space", 0x036b1): "NativeScopeInfo",
("read_only_space", 0x036c9): "HashSeed",
("old_space", 0x04215): "ArgumentsIteratorAccessor",
("old_space", 0x04259): "ArrayLengthAccessor",
("old_space", 0x0429d): "BoundFunctionLengthAccessor",
("old_space", 0x042e1): "BoundFunctionNameAccessor",
("old_space", 0x04325): "ErrorStackAccessor",
("old_space", 0x04369): "FunctionArgumentsAccessor",
("old_space", 0x043ad): "FunctionCallerAccessor",
("old_space", 0x043f1): "FunctionNameAccessor",
("old_space", 0x04435): "FunctionLengthAccessor",
("old_space", 0x04479): "FunctionPrototypeAccessor",
("old_space", 0x044bd): "StringLengthAccessor",
("old_space", 0x04501): "InvalidPrototypeValidityCell",
("old_space", 0x04509): "EmptyScript",
("old_space", 0x04549): "ManyClosuresCell",
("old_space", 0x04555): "ArrayConstructorProtector",
("old_space", 0x04569): "NoElementsProtector",
("old_space", 0x0457d): "MegaDOMProtector",
("old_space", 0x04591): "IsConcatSpreadableProtector",
("old_space", 0x045a5): "ArraySpeciesProtector",
("old_space", 0x045b9): "TypedArraySpeciesProtector",
("old_space", 0x045cd): "PromiseSpeciesProtector",
("old_space", 0x045e1): "RegExpSpeciesProtector",
("old_space", 0x045f5): "StringLengthProtector",
("old_space", 0x04609): "ArrayIteratorProtector",
("old_space", 0x0461d): "ArrayBufferDetachingProtector",
("old_space", 0x04631): "PromiseHookProtector",
("old_space", 0x04645): "PromiseResolveProtector",
("old_space", 0x04659): "MapIteratorProtector",
("old_space", 0x0466d): "PromiseThenProtector",
("old_space", 0x04681): "SetIteratorProtector",
("old_space", 0x04695): "StringIteratorProtector",
("old_space", 0x046a9): "SingleCharacterStringCache",
("old_space", 0x04ab1): "StringSplitCache",
("old_space", 0x04eb9): "RegExpMultipleCache",
("old_space", 0x052c1): "BuiltinsConstantsTable",
("old_space", 0x056ed): "AsyncFunctionAwaitRejectSharedFun",
("old_space", 0x05711): "AsyncFunctionAwaitResolveSharedFun",
("old_space", 0x05735): "AsyncGeneratorAwaitRejectSharedFun",
("old_space", 0x05759): "AsyncGeneratorAwaitResolveSharedFun",
("old_space", 0x0577d): "AsyncGeneratorYieldResolveSharedFun",
("old_space", 0x057a1): "AsyncGeneratorReturnResolveSharedFun",
("old_space", 0x057c5): "AsyncGeneratorReturnClosedRejectSharedFun",
("old_space", 0x057e9): "AsyncGeneratorReturnClosedResolveSharedFun",
("old_space", 0x0580d): "AsyncIteratorValueUnwrapSharedFun",
("old_space", 0x05831): "PromiseAllResolveElementSharedFun",
("old_space", 0x05855): "PromiseAllSettledResolveElementSharedFun",
("old_space", 0x05879): "PromiseAllSettledRejectElementSharedFun",
("old_space", 0x0589d): "PromiseAnyRejectElementSharedFun",
("old_space", 0x058c1): "PromiseCapabilityDefaultRejectSharedFun",
("old_space", 0x058e5): "PromiseCapabilityDefaultResolveSharedFun",
("old_space", 0x05909): "PromiseCatchFinallySharedFun",
("old_space", 0x0592d): "PromiseGetCapabilitiesExecutorSharedFun",
("old_space", 0x05951): "PromiseThenFinallySharedFun",
("old_space", 0x05975): "PromiseThrowerFinallySharedFun",
("old_space", 0x05999): "PromiseValueThunkFinallySharedFun",
("old_space", 0x059bd): "ProxyRevokeSharedFun",
("read_only_space", 0x021f1): "EmptyWeakArrayList",
("read_only_space", 0x021fd): "EmptyDescriptorArray",
("read_only_space", 0x02235): "EmptyEnumCache",
("read_only_space", 0x02269): "EmptyFixedArray",
("read_only_space", 0x02271): "NullValue",
("read_only_space", 0x02379): "UninitializedValue",
("read_only_space", 0x023f1): "UndefinedValue",
("read_only_space", 0x02435): "NanValue",
("read_only_space", 0x02469): "TheHoleValue",
("read_only_space", 0x02495): "HoleNanValue",
("read_only_space", 0x024c9): "TrueValue",
("read_only_space", 0x02509): "FalseValue",
("read_only_space", 0x02539): "empty_string",
("read_only_space", 0x02775): "EmptyScopeInfo",
("read_only_space", 0x027ad): "ArgumentsMarker",
("read_only_space", 0x0280d): "Exception",
("read_only_space", 0x02869): "TerminationException",
("read_only_space", 0x028d1): "OptimizedOut",
("read_only_space", 0x02931): "StaleRegister",
("read_only_space", 0x03431): "EmptyPropertyArray",
("read_only_space", 0x03439): "EmptyByteArray",
("read_only_space", 0x03441): "EmptyObjectBoilerplateDescription",
("read_only_space", 0x03475): "EmptyArrayBoilerplateDescription",
("read_only_space", 0x03481): "EmptyClosureFeedbackCellArray",
("read_only_space", 0x03489): "EmptySlowElementDictionary",
("read_only_space", 0x034ad): "EmptyOrderedHashMap",
("read_only_space", 0x034c1): "EmptyOrderedHashSet",
("read_only_space", 0x034d5): "EmptyFeedbackMetadata",
("read_only_space", 0x034e1): "EmptyPropertyDictionary",
("read_only_space", 0x03509): "EmptyOrderedPropertyDictionary",
("read_only_space", 0x03521): "EmptySwissPropertyDictionary",
("read_only_space", 0x03575): "NoOpInterceptorInfo",
("read_only_space", 0x0359d): "EmptyArrayList",
("read_only_space", 0x035a9): "EmptyWeakFixedArray",
("read_only_space", 0x035b1): "InfinityValue",
("read_only_space", 0x035bd): "MinusZeroValue",
("read_only_space", 0x035c9): "MinusInfinityValue",
("read_only_space", 0x035d5): "SelfReferenceMarker",
("read_only_space", 0x03615): "BasicBlockCountersMarker",
("read_only_space", 0x03659): "OffHeapTrampolineRelocationInfo",
("read_only_space", 0x03665): "GlobalThisBindingScopeInfo",
("read_only_space", 0x03695): "EmptyFunctionScopeInfo",
("read_only_space", 0x036b9): "NativeScopeInfo",
("read_only_space", 0x036d1): "HashSeed",
("old_space", 0x0421d): "ArgumentsIteratorAccessor",
("old_space", 0x04261): "ArrayLengthAccessor",
("old_space", 0x042a5): "BoundFunctionLengthAccessor",
("old_space", 0x042e9): "BoundFunctionNameAccessor",
("old_space", 0x0432d): "ErrorStackAccessor",
("old_space", 0x04371): "FunctionArgumentsAccessor",
("old_space", 0x043b5): "FunctionCallerAccessor",
("old_space", 0x043f9): "FunctionNameAccessor",
("old_space", 0x0443d): "FunctionLengthAccessor",
("old_space", 0x04481): "FunctionPrototypeAccessor",
("old_space", 0x044c5): "StringLengthAccessor",
("old_space", 0x04509): "InvalidPrototypeValidityCell",
("old_space", 0x04511): "EmptyScript",
("old_space", 0x04551): "ManyClosuresCell",
("old_space", 0x0455d): "ArrayConstructorProtector",
("old_space", 0x04571): "NoElementsProtector",
("old_space", 0x04585): "MegaDOMProtector",
("old_space", 0x04599): "IsConcatSpreadableProtector",
("old_space", 0x045ad): "ArraySpeciesProtector",
("old_space", 0x045c1): "TypedArraySpeciesProtector",
("old_space", 0x045d5): "PromiseSpeciesProtector",
("old_space", 0x045e9): "RegExpSpeciesProtector",
("old_space", 0x045fd): "StringLengthProtector",
("old_space", 0x04611): "ArrayIteratorProtector",
("old_space", 0x04625): "ArrayBufferDetachingProtector",
("old_space", 0x04639): "PromiseHookProtector",
("old_space", 0x0464d): "PromiseResolveProtector",
("old_space", 0x04661): "MapIteratorProtector",
("old_space", 0x04675): "PromiseThenProtector",
("old_space", 0x04689): "SetIteratorProtector",
("old_space", 0x0469d): "StringIteratorProtector",
("old_space", 0x046b1): "SingleCharacterStringCache",
("old_space", 0x04ab9): "StringSplitCache",
("old_space", 0x04ec1): "RegExpMultipleCache",
("old_space", 0x052c9): "BuiltinsConstantsTable",
("old_space", 0x056f5): "AsyncFunctionAwaitRejectSharedFun",
("old_space", 0x05719): "AsyncFunctionAwaitResolveSharedFun",
("old_space", 0x0573d): "AsyncGeneratorAwaitRejectSharedFun",
("old_space", 0x05761): "AsyncGeneratorAwaitResolveSharedFun",
("old_space", 0x05785): "AsyncGeneratorYieldResolveSharedFun",
("old_space", 0x057a9): "AsyncGeneratorReturnResolveSharedFun",
("old_space", 0x057cd): "AsyncGeneratorReturnClosedRejectSharedFun",
("old_space", 0x057f1): "AsyncGeneratorReturnClosedResolveSharedFun",
("old_space", 0x05815): "AsyncIteratorValueUnwrapSharedFun",
("old_space", 0x05839): "PromiseAllResolveElementSharedFun",
("old_space", 0x0585d): "PromiseAllSettledResolveElementSharedFun",
("old_space", 0x05881): "PromiseAllSettledRejectElementSharedFun",
("old_space", 0x058a5): "PromiseAnyRejectElementSharedFun",
("old_space", 0x058c9): "PromiseCapabilityDefaultRejectSharedFun",
("old_space", 0x058ed): "PromiseCapabilityDefaultResolveSharedFun",
("old_space", 0x05911): "PromiseCatchFinallySharedFun",
("old_space", 0x05935): "PromiseGetCapabilitiesExecutorSharedFun",
("old_space", 0x05959): "PromiseThenFinallySharedFun",
("old_space", 0x0597d): "PromiseThrowerFinallySharedFun",
("old_space", 0x059a1): "PromiseValueThunkFinallySharedFun",
("old_space", 0x059c5): "ProxyRevokeSharedFun",
}
# Lower 32 bits of first page addresses for various heap spaces.