paged-spaces.cc | Explore in Territory

// Copyright 2020 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/paged-spaces.h"

#include <atomic>

#include "src/base/logging.h"
#include "src/base/platform/mutex.h"
#include "src/common/globals.h"
#include "src/execution/isolate.h"
#include "src/execution/vm-state-inl.h"
#include "src/flags/flags.h"
#include "src/heap/allocation-observer.h"
#include "src/heap/array-buffer-sweeper.h"
#include "src/heap/free-list-inl.h"
#include "src/heap/gc-tracer-inl.h"
#include "src/heap/gc-tracer.h"
#include "src/heap/heap.h"
#include "src/heap/incremental-marking.h"
#include "src/heap/marking-state-inl.h"
#include "src/heap/memory-allocator.h"
#include "src/heap/memory-chunk-layout.h"
#include "src/heap/mutable-page-metadata-inl.h"
#include "src/heap/page-metadata-inl.h"
#include "src/heap/paged-spaces-inl.h"
#include "src/heap/read-only-heap.h"
#include "src/heap/safepoint.h"
#include "src/heap/spaces.h"
#include "src/heap/sweeper.h"
#include "src/logging/runtime-call-stats-scope.h"
#include "src/objects/string.h"
#include "src/utils/utils.h"

namespace v8 {
namespace internal {

// ----------------------------------------------------------------------------
// PagedSpaceObjectIterator

PagedSpaceObjectIterator::PagedSpaceObjectIterator(Heap* heap,
                                                   const PagedSpaceBase* space)
    : … { … }

// We have hit the end of the page and should advance to the next block of
// objects.  This happens at the end of the page.
bool PagedSpaceObjectIterator::AdvanceToNextPage() { … }

// ----------------------------------------------------------------------------
// PagedSpaceBase implementation

PagedSpaceBase::PagedSpaceBase(Heap* heap, AllocationSpace space,
                               Executability executable,
                               std::unique_ptr<FreeList> free_list,
                               CompactionSpaceKind compaction_space_kind)
    : … { … }

PageMetadata* PagedSpaceBase::InitializePage(
    MutablePageMetadata* mutable_page_metadata) { … }

void PagedSpaceBase::TearDown() { … }

void PagedSpaceBase::MergeCompactionSpace(CompactionSpace* other) { … }

size_t PagedSpaceBase::CommittedPhysicalMemory() const { … }

void PagedSpaceBase::IncrementCommittedPhysicalMemory(size_t increment_value) { … }

void PagedSpaceBase::DecrementCommittedPhysicalMemory(size_t decrement_value) { … }

#if DEBUG
void PagedSpaceBase::VerifyCommittedPhysicalMemory() const { … }
#endif  // DEBUG

bool PagedSpaceBase::ContainsSlow(Address addr) const { … }

void PagedSpaceBase::RefineAllocatedBytesAfterSweeping(PageMetadata* page) { … }

PageMetadata* PagedSpaceBase::RemovePageSafe(int size_in_bytes) { … }

void PagedSpaceBase::AddPageImpl(PageMetadata* page) { … }

size_t PagedSpaceBase::AddPage(PageMetadata* page) { … }

void PagedSpaceBase::RemovePage(PageMetadata* page) { … }

size_t PagedSpaceBase::ShrinkPageToHighWaterMark(PageMetadata* page) { … }

void PagedSpaceBase::ResetFreeList() { … }

void PagedSpaceBase::ShrinkImmortalImmovablePages() { … }

bool PagedSpaceBase::TryExpand(LocalHeap* local_heap, AllocationOrigin origin) { … }

int PagedSpaceBase::CountTotalPages() const { … }

size_t PagedSpaceBase::Available() const { … }

size_t PagedSpaceBase::Waste() const { … }

void PagedSpaceBase::ReleasePage(PageMetadata* page) { … }

void PagedSpaceBase::ReleasePageImpl(PageMetadata* page,
                                     MemoryAllocator::FreeMode free_mode) { … }

std::unique_ptr<ObjectIterator> PagedSpaceBase::GetObjectIterator(Heap* heap) { … }

#ifdef DEBUG
void PagedSpaceBase::Print() { … }
#endif

#ifdef VERIFY_HEAP
void PagedSpaceBase::Verify(Isolate* isolate,
                            SpaceVerificationVisitor* visitor) const { … }

void PagedSpaceBase::VerifyLiveBytes() const { … }
#endif  // VERIFY_HEAP

#ifdef DEBUG
void PagedSpaceBase::VerifyCountersAfterSweeping(Heap* heap) const { … }

void PagedSpaceBase::VerifyCountersBeforeConcurrentSweeping() const { … }
#endif

void PagedSpaceBase::AddRangeToActiveSystemPages(PageMetadata* page,
                                                 Address start, Address end) { … }

void PagedSpaceBase::ReduceActiveSystemPages(
    PageMetadata* page, ActiveSystemPages active_system_pages) { … }

void PagedSpaceBase::UnlinkFreeListCategories(PageMetadata* page) { … }

size_t PagedSpaceBase::RelinkFreeListCategories(PageMetadata* page) { … }

namespace {

void DropFreeListCategories(PageMetadata* page, FreeList* free_list) { … }

}  // namespace

void PagedSpaceBase::RefillFreeList() { … }

AllocatorPolicy* PagedSpace::CreateAllocatorPolicy(MainAllocator* allocator) { … }

// -----------------------------------------------------------------------------
// CompactionSpace implementation

void CompactionSpace::NotifyNewPage(PageMetadata* page) { … }

void CompactionSpace::RefillFreeList() { … }

CompactionSpaceCollection::CompactionSpaceCollection(
    Heap* heap, CompactionSpaceKind compaction_space_kind)
    : … { … }

// -----------------------------------------------------------------------------
// OldSpace implementation

void OldSpace::AddPromotedPage(PageMetadata* page) { … }

void OldSpace::ReleasePage(PageMetadata* page) { … }

// -----------------------------------------------------------------------------
// StickySpace implementation

void StickySpace::AdjustDifferenceInAllocatedBytes(size_t diff) { … }

// -----------------------------------------------------------------------------
// SharedSpace implementation

void SharedSpace::ReleasePage(PageMetadata* page) { … }

}  // namespace internal
}  // namespace v8
chromium/v8/src/heap/paged-spaces.cc
