v8::internal::PagedSpace Class Reference

#include <spaces.h>

Inheritance diagram for v8::internal::PagedSpace:

Collaboration diagram for v8::internal::PagedSpace:

Classes
struct	SizeStats

Public Member Functions
	PagedSpace (Heap *heap, intptr_t max_capacity, AllocationSpace id, Executability executable)
virtual	~PagedSpace ()
bool	SetUp ()
bool	HasBeenSetUp ()
void	TearDown ()
bool	Contains (Address a)
bool	Contains (HeapObject *o)
Object *	FindObject (Address addr)
void	RepairFreeListsAfterBoot ()
void	PrepareForMarkCompact ()
intptr_t	Capacity ()
intptr_t	CommittedMemory ()
intptr_t	MaximumCommittedMemory ()
size_t	CommittedPhysicalMemory ()
void	ObtainFreeListStatistics (Page *p, SizeStats *sizes)
void	ResetFreeListStatistics ()
void	ClearStats ()
void	AddToAccountingStats (intptr_t bytes)
intptr_t	Available ()
virtual intptr_t	Size ()
virtual intptr_t	SizeOfObjects ()
virtual intptr_t	Waste ()
Address	top ()
Address	limit ()
Address *	allocation_top_address ()
Address *	allocation_limit_address ()
MUST_USE_RESULT AllocationResult	AllocateRaw (int size_in_bytes)
int	Free (Address start, int size_in_bytes)
void	ResetFreeList ()
void	SetTopAndLimit (Address top, Address limit)
void	EmptyAllocationInfo ()
void	Allocate (int bytes)
void	IncreaseCapacity (int size)
void	ReleasePage (Page *page)
Page *	anchor ()
void	IncrementUnsweptFreeBytes (intptr_t by)
void	IncreaseUnsweptFreeBytes (Page *p)
void	DecrementUnsweptFreeBytes (intptr_t by)
void	DecreaseUnsweptFreeBytes (Page *p)
void	ResetUnsweptFreeBytes ()
bool	EnsureSweeperProgress (intptr_t size_in_bytes)
void	set_end_of_unswept_pages (Page *page)
Page *	end_of_unswept_pages ()
Page *	FirstPage ()
Page *	LastPage ()
void	EvictEvacuationCandidatesFromFreeLists ()
bool	CanExpand ()
int	CountTotalPages ()
int	AreaSize ()
void	CreateEmergencyMemory ()
void	FreeEmergencyMemory ()
void	UseEmergencyMemory ()
bool	HasEmergencyMemory ()
Public Member Functions inherited from v8::internal::Space
	Space (Heap *heap, AllocationSpace id, Executability executable)
virtual	~Space ()
Heap *	heap () const
Executability	executable ()
AllocationSpace	identity ()
virtual int	RoundSizeDownToObjectAlignment (int size)
Public Member Functions inherited from v8::internal::Malloced
void *	operator new (size_t size)
void	operator delete (void *p)

Static Public Member Functions
static bool	ShouldBeSweptBySweeperThreads (Page *p)
Static Public Member Functions inherited from v8::internal::Malloced
static void	FatalProcessOutOfMemory ()
static void *	New (size_t size)
static void	Delete (void *p)

Protected Member Functions
FreeList *	free_list ()
intptr_t	SizeOfFirstPage ()
bool	Expand ()
HeapObject *	AllocateLinearly (int size_in_bytes)
MUST_USE_RESULT HeapObject *	WaitForSweeperThreadsAndRetryAllocation (int size_in_bytes)
MUST_USE_RESULT HeapObject *	SlowAllocateRaw (int size_in_bytes)

Protected Attributes
int	area_size_
intptr_t	max_capacity_
AllocationStats	accounting_stats_
Page	anchor_
FreeList	free_list_
AllocationInfo	allocation_info_
intptr_t	unswept_free_bytes_
Page *	end_of_unswept_pages_
MemoryChunk *	emergency_memory_

Friends
class	PageIterator
class	MarkCompactCollector

Detailed Description

Definition at line 1648 of file spaces.h.

Constructor & Destructor Documentation

PagedSpace()

v8::internal::PagedSpace::PagedSpace	(	Heap *	heap,
		intptr_t	max_capacity,
		AllocationSpace	id,
		Executability	executable
	)

Definition at line 880 of file spaces.cc.

    : Space(heap, id, executable),
      free_list_(this),
      unswept_free_bytes_(0),
      end_of_unswept_pages_(NULL),
      emergency_memory_(NULL) {
  if (id == CODE_SPACE) {
    area_size_ = heap->isolate()->memory_allocator()->CodePageAreaSize();
  } else {
    area_size_ = Page::kPageSize - Page::kObjectStartOffset;
  }
  max_capacity_ =
      (RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize) * AreaSize();
  accounting_stats_.Clear();
 
  allocation_info_.set_top(NULL);
  allocation_info_.set_limit(NULL);
 
  anchor_.InitializeAsAnchor(this);
}

References accounting_stats_, allocation_info_, anchor_, area_size_, AreaSize(), v8::internal::CODE_SPACE, v8::internal::MemoryAllocator::CodePageAreaSize(), v8::internal::Space::heap(), v8::internal::Page::InitializeAsAnchor(), v8::internal::Heap::isolate(), v8::internal::MemoryChunk::kObjectStartOffset, v8::internal::Page::kPageSize, max_capacity_, v8::internal::Isolate::memory_allocator(), NULL, and RoundDown().

Here is the call graph for this function:

~PagedSpace()

virtual v8::internal::PagedSpace::~PagedSpace ( )

inlinevirtual

Definition at line 1654 of file spaces.h.

{}

Member Function Documentation

AddToAccountingStats()

void v8::internal::PagedSpace::AddToAccountingStats ( intptr_t  bytes )

inline

Definition at line 1725 of file spaces.h.

                                            {
    accounting_stats_.DeallocateBytes(bytes);
  }

References accounting_stats_.

Allocate()

void v8::internal::PagedSpace::Allocate ( int  bytes )

inline

Definition at line 1797 of file spaces.h.

{ accounting_stats_.AllocateBytes(bytes); }

References accounting_stats_.

Referenced by v8::internal::FreeList::Allocate().

Here is the caller graph for this function:

AllocateLinearly()

HeapObject * v8::internal::PagedSpace::AllocateLinearly ( int  size_in_bytes )

inlineprotected

Definition at line 237 of file spaces-inl.h.

                                                          {
  Address current_top = allocation_info_.top();
  Address new_top = current_top + size_in_bytes;
  if (new_top > allocation_info_.limit()) return NULL;
 
  allocation_info_.set_top(new_top);
  return HeapObject::FromAddress(current_top);
}

References allocation_info_, v8::internal::HeapObject::FromAddress(), and NULL.

Referenced by AllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateRaw()

AllocationResult v8::internal::PagedSpace::AllocateRaw ( int  size_in_bytes )

inline

Definition at line 248 of file spaces-inl.h.

                                                          {
  HeapObject* object = AllocateLinearly(size_in_bytes);
 
  if (object == NULL) {
    object = free_list_.Allocate(size_in_bytes);
    if (object == NULL) {
      object = SlowAllocateRaw(size_in_bytes);
    }
  }
 
  if (object != NULL) {
    if (identity() == CODE_SPACE) {
      SkipList::Update(object->address(), size_in_bytes);
    }
    MSAN_ALLOCATED_UNINITIALIZED_MEMORY(object->address(), size_in_bytes);
    return object;
  }
 
  return AllocationResult::Retry(identity());
}

References v8::internal::HeapObject::address(), v8::internal::FreeList::Allocate(), AllocateLinearly(), v8::internal::CODE_SPACE, free_list_, v8::internal::Space::identity(), MSAN_ALLOCATED_UNINITIALIZED_MEMORY, NULL, v8::internal::AllocationResult::Retry(), SlowAllocateRaw(), and v8::internal::SkipList::Update().

Referenced by v8::internal::Heap::AllocateRaw(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::PromoteObject(), v8::internal::Heap::ReserveSpace(), and v8::internal::MarkCompactCollector::TryPromoteObject().

Here is the call graph for this function:

Here is the caller graph for this function:

allocation_limit_address()

Address* v8::internal::PagedSpace::allocation_limit_address ( )

inline

Definition at line 1758 of file spaces.h.

                                      {
    return allocation_info_.limit_address();
  }

References allocation_info_, and v8::internal::AllocationInfo::limit_address().

Referenced by v8::internal::Heap::OldDataSpaceAllocationLimitAddress(), and v8::internal::Heap::OldPointerSpaceAllocationLimitAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

allocation_top_address()

Address* v8::internal::PagedSpace::allocation_top_address ( )

inline

Definition at line 1755 of file spaces.h.

{ return allocation_info_.top_address(); }

References allocation_info_, and v8::internal::AllocationInfo::top_address().

Referenced by v8::internal::Heap::OldDataSpaceAllocationTopAddress(), and v8::internal::Heap::OldPointerSpaceAllocationTopAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

anchor()

Page* v8::internal::PagedSpace::anchor ( )

inline

Definition at line 1805 of file spaces.h.

{ return &anchor_; }

References anchor_.

Referenced by v8::internal::HeapObjectIterator::AdvanceToNextPage().

Here is the caller graph for this function:

AreaSize()

int v8::internal::PagedSpace::AreaSize ( )

inline

Definition at line 1873 of file spaces.h.

{ return area_size_; }

References area_size_.

Referenced by CanExpand(), CreateEmergencyMemory(), Expand(), FreeEmergencyMemory(), PagedSpace(), ReleasePage(), and SizeOfFirstPage().

Here is the caller graph for this function:

Available()

intptr_t v8::internal::PagedSpace::Available ( )

inline

Definition at line 1733 of file spaces.h.

{ return free_list_.available(); }

References v8::internal::FreeList::available(), and free_list_.

Referenced by v8::internal::Heap::Available(), v8::internal::StatisticsExtension::GetCounters(), and v8::internal::Heap::PrintShortHeapStatistics().

Here is the call graph for this function:

Here is the caller graph for this function:

CanExpand()

bool v8::internal::PagedSpace::CanExpand

(

)

Definition at line 951 of file spaces.cc.

                           {
  DCHECK(max_capacity_ % AreaSize() == 0);
 
  if (Capacity() == max_capacity_) return false;
 
  DCHECK(Capacity() < max_capacity_);
 
  // Are we going to exceed capacity for this space?
  if ((Capacity() + Page::kPageSize) > max_capacity_) return false;
 
  return true;
}

References AreaSize(), Capacity(), DCHECK, v8::internal::Page::kPageSize, and max_capacity_.

Referenced by Expand().

Here is the call graph for this function:

Here is the caller graph for this function:

Capacity()

intptr_t v8::internal::PagedSpace::Capacity ( )

inline

Definition at line 1688 of file spaces.h.

{ return accounting_stats_.Capacity(); }

References accounting_stats_.

Referenced by CanExpand(), v8::internal::Heap::Capacity(), CommittedMemory(), Expand(), v8::internal::Heap::RecordStats(), and ReleasePage().

Here is the caller graph for this function:

ClearStats()

void v8::internal::PagedSpace::ClearStats ( )

inline

Definition at line 1719 of file spaces.h.

                    {
    accounting_stats_.ClearSizeWaste();
    ResetFreeListStatistics();
  }

References accounting_stats_, and ResetFreeListStatistics().

Here is the call graph for this function:

CommittedMemory()

intptr_t v8::internal::PagedSpace::CommittedMemory ( )

inline

Definition at line 1692 of file spaces.h.

{ return Capacity(); }

References Capacity().

Referenced by v8::internal::Heap::CommittedMemory(), CommittedPhysicalMemory(), v8::internal::StatisticsExtension::GetCounters(), and v8::internal::Heap::PrintShortHeapStatistics().

Here is the call graph for this function:

Here is the caller graph for this function:

CommittedPhysicalMemory()

size_t v8::internal::PagedSpace::CommittedPhysicalMemory

(

)

Definition at line 920 of file spaces.cc.

                                           {
  if (!base::VirtualMemory::HasLazyCommits()) return CommittedMemory();
  MemoryChunk::UpdateHighWaterMark(allocation_info_.top());
  size_t size = 0;
  PageIterator it(this);
  while (it.has_next()) {
    size += it.next()->CommittedPhysicalMemory();
  }
  return size;
}

References allocation_info_, CommittedMemory(), v8::base::VirtualMemory::HasLazyCommits(), PageIterator, size, and v8::internal::MemoryChunk::UpdateHighWaterMark().

Referenced by v8::internal::Heap::CommittedPhysicalMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

Contains() [1/2]

bool v8::internal::PagedSpace::Contains ( Address  a )

inline

Definition at line 150 of file spaces-inl.h.

                                      {
  Page* p = Page::FromAddress(addr);
  if (!p->is_valid()) return false;
  return p->owner() == this;
}

References v8::internal::MemoryChunk::FromAddress(), v8::internal::MemoryChunk::is_valid(), and v8::internal::MemoryChunk::owner().

Referenced by v8::internal::StoreBuffer::ClearDeadObject(), v8::internal::StoreBuffer::Compact(), v8::internal::Heap::Contains(), v8::internal::StoreBuffer::EnterDirectlyIntoStoreBuffer(), FindObject(), v8::internal::Heap::InOldDataSpace(), v8::internal::Heap::InOldPointerSpace(), v8::internal::Heap::InSpace(), and v8::internal::StoreBuffer::Mark().

Here is the call graph for this function:

Here is the caller graph for this function:

Contains() [2/2]

bool v8::internal::PagedSpace::Contains ( HeapObject *  o )

inline

Definition at line 1672 of file spaces.h.

{ return Contains(o->address()); }

References v8::internal::HeapObject::address(), and Contains().

Referenced by Contains().

Here is the call graph for this function:

Here is the caller graph for this function:

CountTotalPages()

int v8::internal::PagedSpace::CountTotalPages

(

)

Definition at line 1028 of file spaces.cc.

                                {
  PageIterator it(this);
  int count = 0;
  while (it.has_next()) {
    it.next();
    count++;
  }
  return count;
}

References PageIterator.

Referenced by SlowAllocateRaw().

Here is the caller graph for this function:

CreateEmergencyMemory()

void v8::internal::PagedSpace::CreateEmergencyMemory

(

)

Definition at line 1097 of file spaces.cc.

                                       {
  emergency_memory_ = heap()->isolate()->memory_allocator()->AllocateChunk(
      AreaSize(), AreaSize(), executable(), this);
}

References v8::internal::MemoryAllocator::AllocateChunk(), AreaSize(), emergency_memory_, v8::internal::Space::executable(), v8::internal::Space::heap(), v8::internal::Heap::isolate(), and v8::internal::Isolate::memory_allocator().

Here is the call graph for this function:

DecreaseUnsweptFreeBytes()

void v8::internal::PagedSpace::DecreaseUnsweptFreeBytes ( Page *  p )

inline

Definition at line 1845 of file spaces.h.

                                         {
    DCHECK(ShouldBeSweptBySweeperThreads(p));
    unswept_free_bytes_ -= (p->area_size() - p->LiveBytes());
  }

References v8::internal::MemoryChunk::area_size(), DCHECK, v8::internal::MemoryChunk::LiveBytes(), ShouldBeSweptBySweeperThreads(), and unswept_free_bytes_.

Referenced by ReleasePage().

Here is the call graph for this function:

Here is the caller graph for this function:

DecrementUnsweptFreeBytes()

void v8::internal::PagedSpace::DecrementUnsweptFreeBytes ( intptr_t  by )

inline

Definition at line 1843 of file spaces.h.

{ unswept_free_bytes_ -= by; }

References unswept_free_bytes_.

EmptyAllocationInfo()

void v8::internal::PagedSpace::EmptyAllocationInfo ( )

inline

Definition at line 1789 of file spaces.h.

                             {
    // Mark the old linear allocation area with a free space map so it can be
    // skipped when scanning the heap.
    int old_linear_size = static_cast<int>(limit() - top());
    Free(top(), old_linear_size);
    SetTopAndLimit(NULL, NULL);
  }

References Free(), limit(), NULL, SetTopAndLimit(), and top().

Referenced by PrepareForMarkCompact().

Here is the call graph for this function:

Here is the caller graph for this function:

end_of_unswept_pages()

Page* v8::internal::PagedSpace::end_of_unswept_pages ( )

inline

Definition at line 1860 of file spaces.h.

{ return end_of_unswept_pages_; }

References end_of_unswept_pages_.

EnsureSweeperProgress()

bool v8::internal::PagedSpace::EnsureSweeperProgress

(

intptr_t

size_in_bytes

)

EvictEvacuationCandidatesFromFreeLists()

void v8::internal::PagedSpace::EvictEvacuationCandidatesFromFreeLists

(

)

Definition at line 2516 of file spaces.cc.

                                                        {
  if (allocation_info_.top() >= allocation_info_.limit()) return;
 
  if (Page::FromAllocationTop(allocation_info_.top())
          ->IsEvacuationCandidate()) {
    // Create filler object to keep page iterable if it was iterable.
    int remaining =
        static_cast<int>(allocation_info_.limit() - allocation_info_.top());
    heap()->CreateFillerObjectAt(allocation_info_.top(), remaining);
 
    allocation_info_.set_top(NULL);
    allocation_info_.set_limit(NULL);
  }
}

References allocation_info_, v8::internal::Heap::CreateFillerObjectAt(), v8::internal::Space::heap(), and NULL.

Referenced by v8::internal::MarkCompactCollector::StartCompaction().

Here is the call graph for this function:

Here is the caller graph for this function:

Expand()

bool v8::internal::PagedSpace::Expand ( )

protected

Definition at line 965 of file spaces.cc.

                        {
  if (!CanExpand()) return false;
 
  intptr_t size = AreaSize();
 
  if (anchor_.next_page() == &anchor_) {
    size = SizeOfFirstPage();
  }
 
  Page* p = heap()->isolate()->memory_allocator()->AllocatePage(size, this,
                                                                executable());
  if (p == NULL) return false;
 
  DCHECK(Capacity() <= max_capacity_);
 
  p->InsertAfter(anchor_.prev_page());
 
  return true;
}

References v8::internal::MemoryAllocator::AllocatePage(), anchor_, AreaSize(), CanExpand(), Capacity(), DCHECK, v8::internal::Space::executable(), v8::internal::Space::heap(), v8::internal::MemoryChunk::InsertAfter(), v8::internal::Heap::isolate(), max_capacity_, v8::internal::Isolate::memory_allocator(), v8::internal::Page::next_page(), NULL, v8::internal::Page::prev_page(), size, and SizeOfFirstPage().

Referenced by SlowAllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

FindObject()

Object * v8::internal::PagedSpace::FindObject

(

Address

addr

)

Definition at line 932 of file spaces.cc.

                                           {
  // Note: this function can only be called on iterable spaces.
  DCHECK(!heap()->mark_compact_collector()->in_use());
 
  if (!Contains(addr)) return Smi::FromInt(0);  // Signaling not found.
 
  Page* p = Page::FromAddress(addr);
  HeapObjectIterator it(p, NULL);
  for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
    Address cur = obj->address();
    Address next = cur + obj->Size();
    if ((cur <= addr) && (addr < next)) return obj;
  }
 
  UNREACHABLE();
  return Smi::FromInt(0);
}

References Contains(), DCHECK, v8::internal::MemoryChunk::FromAddress(), v8::internal::Smi::FromInt(), v8::internal::Space::heap(), v8::internal::HeapObjectIterator::Next(), NULL, and UNREACHABLE.

Here is the call graph for this function:

FirstPage()

Page* v8::internal::PagedSpace::FirstPage ( )

inline

Definition at line 1862 of file spaces.h.

{ return anchor_.next_page(); }

References anchor_, and v8::internal::Page::next_page().

Referenced by v8::internal::Heap::AllocateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

Free()

int v8::internal::PagedSpace::Free ( Address  start, int  size_in_bytes  )

inline

Definition at line 1770 of file spaces.h.

                                             {
    int wasted = free_list_.Free(start, size_in_bytes);
    accounting_stats_.DeallocateBytes(size_in_bytes);
    accounting_stats_.WasteBytes(wasted);
    return size_in_bytes - wasted;
  }

References accounting_stats_, v8::internal::FreeList::Free(), and free_list_.

Referenced by v8::internal::FreeList::Allocate(), and EmptyAllocationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

free_list()

FreeList* v8::internal::PagedSpace::free_list ( )

inlineprotected

Definition at line 1882 of file spaces.h.

{ return &free_list_; }

References free_list_.

FreeEmergencyMemory()

void v8::internal::PagedSpace::FreeEmergencyMemory

(

)

Definition at line 1103 of file spaces.cc.

                                     {
  Page* page = static_cast<Page*>(emergency_memory_);
  DCHECK(page->LiveBytes() == 0);
  DCHECK(AreaSize() == page->area_size());
  DCHECK(!free_list_.ContainsPageFreeListItems(page));
  heap()->isolate()->memory_allocator()->Free(page);
  emergency_memory_ = NULL;
}

References v8::internal::MemoryChunk::area_size(), AreaSize(), v8::internal::FreeList::ContainsPageFreeListItems(), DCHECK, emergency_memory_, v8::internal::MemoryAllocator::Free(), free_list_, v8::internal::Space::heap(), v8::internal::Heap::isolate(), v8::internal::MemoryChunk::LiveBytes(), v8::internal::Isolate::memory_allocator(), and NULL.

Here is the call graph for this function:

HasBeenSetUp()

bool v8::internal::PagedSpace::HasBeenSetUp

(

)

Definition at line 906 of file spaces.cc.

{ return true; }

HasEmergencyMemory()

bool v8::internal::PagedSpace::HasEmergencyMemory ( )

inline

Definition at line 1879 of file spaces.h.

{ return emergency_memory_ != NULL; }

References emergency_memory_, and NULL.

IncreaseCapacity()

void v8::internal::PagedSpace::IncreaseCapacity

(

int

size

)

Definition at line 1056 of file spaces.cc.

                                          {
  accounting_stats_.ExpandSpace(size);
}

References accounting_stats_, and size.

IncreaseUnsweptFreeBytes()

void v8::internal::PagedSpace::IncreaseUnsweptFreeBytes ( Page *  p )

inline

Definition at line 1838 of file spaces.h.

                                         {
    DCHECK(ShouldBeSweptBySweeperThreads(p));
    unswept_free_bytes_ += (p->area_size() - p->LiveBytes());
  }

References v8::internal::MemoryChunk::area_size(), DCHECK, v8::internal::MemoryChunk::LiveBytes(), ShouldBeSweptBySweeperThreads(), and unswept_free_bytes_.

Here is the call graph for this function:

IncrementUnsweptFreeBytes()

void v8::internal::PagedSpace::IncrementUnsweptFreeBytes ( intptr_t  by )

inline

Definition at line 1836 of file spaces.h.

{ unswept_free_bytes_ += by; }

References unswept_free_bytes_.

LastPage()

Page* v8::internal::PagedSpace::LastPage ( )

inline

Definition at line 1863 of file spaces.h.

{ return anchor_.prev_page(); }

References anchor_, and v8::internal::Page::prev_page().

Here is the call graph for this function:

limit()

Address v8::internal::PagedSpace::limit ( )

inline

Definition at line 1752 of file spaces.h.

{ return allocation_info_.limit(); }

References allocation_info_.

Referenced by v8::internal::FreeList::Allocate(), EmptyAllocationInfo(), v8::internal::HeapObjectIterator::FromCurrentPage(), v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), SetTopAndLimit(), and SizeOfObjects().

Here is the caller graph for this function:

MaximumCommittedMemory()

intptr_t v8::internal::PagedSpace::MaximumCommittedMemory ( )

inline

Definition at line 1695 of file spaces.h.

{ return accounting_stats_.MaxCapacity(); }

References accounting_stats_.

Referenced by v8::internal::Heap::TearDown().

Here is the caller graph for this function:

ObtainFreeListStatistics()

void v8::internal::PagedSpace::ObtainFreeListStatistics	(	Page *	p,
		SizeStats *	sizes
	)

Definition at line 1039 of file spaces.cc.

                                                                      {
  sizes->huge_size_ = page->available_in_huge_free_list();
  sizes->small_size_ = page->available_in_small_free_list();
  sizes->medium_size_ = page->available_in_medium_free_list();
  sizes->large_size_ = page->available_in_large_free_list();
}

References v8::internal::PagedSpace::SizeStats::huge_size_, v8::internal::PagedSpace::SizeStats::large_size_, v8::internal::PagedSpace::SizeStats::medium_size_, and v8::internal::PagedSpace::SizeStats::small_size_.

PrepareForMarkCompact()

void v8::internal::PagedSpace::PrepareForMarkCompact

(

)

Definition at line 2488 of file spaces.cc.

                                       {
  // We don't have a linear allocation area while sweeping.  It will be restored
  // on the first allocation after the sweep.
  EmptyAllocationInfo();
 
  // This counter will be increased for pages which will be swept by the
  // sweeper threads.
  unswept_free_bytes_ = 0;
 
  // Clear the free list before a full GC---it will be rebuilt afterward.
  free_list_.Reset();
}

References EmptyAllocationInfo(), free_list_, v8::internal::FreeList::Reset(), and unswept_free_bytes_.

Here is the call graph for this function:

ReleasePage()

void v8::internal::PagedSpace::ReleasePage

(

Page *

page

)

Definition at line 1061 of file spaces.cc.

                                       {
  DCHECK(page->LiveBytes() == 0);
  DCHECK(AreaSize() == page->area_size());
 
  if (page->WasSwept()) {
    intptr_t size = free_list_.EvictFreeListItems(page);
    accounting_stats_.AllocateBytes(size);
    DCHECK_EQ(AreaSize(), static_cast<int>(size));
  } else {
    DecreaseUnsweptFreeBytes(page);
  }
 
  if (page->IsFlagSet(MemoryChunk::SCAN_ON_SCAVENGE)) {
    heap()->decrement_scan_on_scavenge_pages();
    page->ClearFlag(MemoryChunk::SCAN_ON_SCAVENGE);
  }
 
  DCHECK(!free_list_.ContainsPageFreeListItems(page));
 
  if (Page::FromAllocationTop(allocation_info_.top()) == page) {
    allocation_info_.set_top(NULL);
    allocation_info_.set_limit(NULL);
  }
 
  page->Unlink();
  if (page->IsFlagSet(MemoryChunk::CONTAINS_ONLY_DATA)) {
    heap()->isolate()->memory_allocator()->Free(page);
  } else {
    heap()->QueueMemoryChunkForFree(page);
  }
 
  DCHECK(Capacity() > 0);
  accounting_stats_.ShrinkSpace(AreaSize());
}

References accounting_stats_, allocation_info_, v8::internal::MemoryChunk::area_size(), AreaSize(), Capacity(), v8::internal::MemoryChunk::ClearFlag(), v8::internal::MemoryChunk::CONTAINS_ONLY_DATA, v8::internal::FreeList::ContainsPageFreeListItems(), DCHECK, DCHECK_EQ, DecreaseUnsweptFreeBytes(), v8::internal::Heap::decrement_scan_on_scavenge_pages(), v8::internal::FreeList::EvictFreeListItems(), v8::internal::MemoryAllocator::Free(), free_list_, v8::internal::Space::heap(), v8::internal::MemoryChunk::IsFlagSet(), v8::internal::Heap::isolate(), v8::internal::MemoryChunk::LiveBytes(), v8::internal::Isolate::memory_allocator(), NULL, v8::internal::Heap::QueueMemoryChunkForFree(), v8::internal::MemoryChunk::SCAN_ON_SCAVENGE, size, v8::internal::MemoryChunk::Unlink(), and v8::internal::Page::WasSwept().

Here is the call graph for this function:

RepairFreeListsAfterBoot()

void v8::internal::PagedSpace::RepairFreeListsAfterBoot

(

)

Definition at line 2513 of file spaces.cc.

{ free_list_.RepairLists(heap()); }

References free_list_, v8::internal::Space::heap(), and v8::internal::FreeList::RepairLists().

Here is the call graph for this function:

ResetFreeList()

void v8::internal::PagedSpace::ResetFreeList ( )

inline

Definition at line 1777 of file spaces.h.

{ free_list_.Reset(); }

References free_list_, and v8::internal::FreeList::Reset().

Here is the call graph for this function:

ResetFreeListStatistics()

void v8::internal::PagedSpace::ResetFreeListStatistics

(

)

Definition at line 1047 of file spaces.cc.

                                         {
  PageIterator page_iterator(this);
  while (page_iterator.has_next()) {
    Page* page = page_iterator.next();
    page->ResetFreeListStatistics();
  }
}

References PageIterator, and v8::internal::Page::ResetFreeListStatistics().

Referenced by ClearStats().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetUnsweptFreeBytes()

void v8::internal::PagedSpace::ResetUnsweptFreeBytes ( )

inline

Definition at line 1850 of file spaces.h.

{ unswept_free_bytes_ = 0; }

References unswept_free_bytes_.

Referenced by v8::internal::MarkCompactCollector::EnsureSweepingCompleted().

Here is the caller graph for this function:

set_end_of_unswept_pages()

void v8::internal::PagedSpace::set_end_of_unswept_pages ( Page *  page )

inline

Definition at line 1858 of file spaces.h.

{ end_of_unswept_pages_ = page; }

References end_of_unswept_pages_.

SetTopAndLimit()

void v8::internal::PagedSpace::SetTopAndLimit ( Address  top, Address  limit  )

inline

Definition at line 1780 of file spaces.h.

                                                  {
    DCHECK(top == limit ||
           Page::FromAddress(top) == Page::FromAddress(limit - 1));
    MemoryChunk::UpdateHighWaterMark(allocation_info_.top());
    allocation_info_.set_top(top);
    allocation_info_.set_limit(limit);
  }

References allocation_info_, DCHECK, v8::internal::MemoryChunk::FromAddress(), limit(), top(), and v8::internal::MemoryChunk::UpdateHighWaterMark().

Referenced by v8::internal::FreeList::Allocate(), and EmptyAllocationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUp()

bool v8::internal::PagedSpace::SetUp

(

)

Definition at line 903 of file spaces.cc.

{ return true; }

Referenced by v8::internal::Heap::SetUp().

Here is the caller graph for this function:

ShouldBeSweptBySweeperThreads()

static bool v8::internal::PagedSpace::ShouldBeSweptBySweeperThreads ( Page *  p )

inlinestatic

Definition at line 1831 of file spaces.h.

                                                     {
    return !p->IsEvacuationCandidate() &&
           !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) && !p->WasSwept();
  }

References v8::internal::MemoryChunk::IsEvacuationCandidate(), v8::internal::MemoryChunk::IsFlagSet(), v8::internal::MemoryChunk::RESCAN_ON_EVACUATION, and v8::internal::Page::WasSwept().

Referenced by DecreaseUnsweptFreeBytes(), and IncreaseUnsweptFreeBytes().

Here is the call graph for this function:

Here is the caller graph for this function:

Size()

virtual intptr_t v8::internal::PagedSpace::Size ( )

inlinevirtual

Implements v8::internal::Space.

Definition at line 1739 of file spaces.h.

{ return accounting_stats_.Size(); }

References accounting_stats_.

Referenced by v8::internal::StatisticsExtension::GetCounters(), and SizeOfObjects().

Here is the caller graph for this function:

SizeOfFirstPage()

intptr_t v8::internal::PagedSpace::SizeOfFirstPage ( )

protected

Definition at line 986 of file spaces.cc.

                                     {
  // If using an ool constant pool then transfer the constant pool allowance
  // from the code space to the old pointer space.
  static const int constant_pool_delta = FLAG_enable_ool_constant_pool ? 48 : 0;
  int size = 0;
  switch (identity()) {
    case OLD_POINTER_SPACE:
      size = (112 + constant_pool_delta) * kPointerSize * KB;
      break;
    case OLD_DATA_SPACE:
      size = 192 * KB;
      break;
    case MAP_SPACE:
      size = 16 * kPointerSize * KB;
      break;
    case CELL_SPACE:
      size = 16 * kPointerSize * KB;
      break;
    case PROPERTY_CELL_SPACE:
      size = 8 * kPointerSize * KB;
      break;
    case CODE_SPACE: {
      CodeRange* code_range = heap()->isolate()->code_range();
      if (code_range != NULL && code_range->valid()) {
        // When code range exists, code pages are allocated in a special way
        // (from the reserved code range). That part of the code is not yet
        // upgraded to handle small pages.
        size = AreaSize();
      } else {
        size = RoundUp((480 - constant_pool_delta) * KB *
                           FullCodeGenerator::kBootCodeSizeMultiplier / 100,
                       kPointerSize);
      }
      break;
    }
    default:
      UNREACHABLE();
  }
  return Min(size, AreaSize());
}

References AreaSize(), v8::internal::CELL_SPACE, v8::internal::Isolate::code_range(), v8::internal::CODE_SPACE, v8::internal::Space::heap(), v8::internal::Space::identity(), v8::internal::Heap::isolate(), v8::internal::KB, v8::internal::kPointerSize, v8::internal::MAP_SPACE, v8::internal::Min(), NULL, v8::internal::OLD_DATA_SPACE, v8::internal::OLD_POINTER_SPACE, v8::internal::PROPERTY_CELL_SPACE, v8::internal::RoundUp(), size, UNREACHABLE, and v8::internal::CodeRange::valid().

Referenced by Expand().

Here is the call graph for this function:

Here is the caller graph for this function:

SizeOfObjects()

intptr_t v8::internal::PagedSpace::SizeOfObjects ( )

virtual

Reimplemented from v8::internal::Space.

Definition at line 2502 of file spaces.cc.

                                   {
  DCHECK(heap()->mark_compact_collector()->sweeping_in_progress() ||
         (unswept_free_bytes_ == 0));
  return Size() - unswept_free_bytes_ - (limit() - top());
}

References DCHECK, v8::internal::Space::heap(), limit(), Size(), top(), and unswept_free_bytes_.

Referenced by v8::internal::Heap::PrintShortHeapStatistics(), v8::internal::Heap::PromotedSpaceSizeOfObjects(), and v8::internal::Heap::RecordStats().

Here is the call graph for this function:

Here is the caller graph for this function:

SlowAllocateRaw()

HeapObject * v8::internal::PagedSpace::SlowAllocateRaw ( int  size_in_bytes )

protected

Definition at line 2547 of file spaces.cc.

                                                         {
  // Allocation in this space has failed.
 
  MarkCompactCollector* collector = heap()->mark_compact_collector();
  // Sweeping is still in progress.
  if (collector->sweeping_in_progress()) {
    // First try to refill the free-list, concurrent sweeper threads
    // may have freed some objects in the meantime.
    collector->RefillFreeList(this);
 
    // Retry the free list allocation.
    HeapObject* object = free_list_.Allocate(size_in_bytes);
    if (object != NULL) return object;
 
    // If sweeping is still in progress try to sweep pages on the main thread.
    int free_chunk = collector->SweepInParallel(this, size_in_bytes);
    collector->RefillFreeList(this);
    if (free_chunk >= size_in_bytes) {
      HeapObject* object = free_list_.Allocate(size_in_bytes);
      // We should be able to allocate an object here since we just freed that
      // much memory.
      DCHECK(object != NULL);
      if (object != NULL) return object;
    }
  }
 
  // Free list allocation failed and there is no next page.  Fail if we have
  // hit the old generation size limit that should cause a garbage
  // collection.
  if (!heap()->always_allocate() &&
      heap()->OldGenerationAllocationLimitReached()) {
    // If sweeper threads are active, wait for them at that point and steal
    // elements form their free-lists.
    HeapObject* object = WaitForSweeperThreadsAndRetryAllocation(size_in_bytes);
    if (object != NULL) return object;
  }
 
  // Try to expand the space and allocate in the new next page.
  if (Expand()) {
    DCHECK(CountTotalPages() > 1 || size_in_bytes <= free_list_.available());
    return free_list_.Allocate(size_in_bytes);
  }
 
  // If sweeper threads are active, wait for them at that point and steal
  // elements form their free-lists. Allocation may still fail their which
  // would indicate that there is not enough memory for the given allocation.
  return WaitForSweeperThreadsAndRetryAllocation(size_in_bytes);
}

References v8::internal::FreeList::Allocate(), v8::internal::FreeList::available(), CountTotalPages(), DCHECK, Expand(), free_list_, v8::internal::Space::heap(), v8::internal::Heap::mark_compact_collector(), NULL, v8::internal::MarkCompactCollector::RefillFreeList(), v8::internal::MarkCompactCollector::sweeping_in_progress(), v8::internal::MarkCompactCollector::SweepInParallel(), and WaitForSweeperThreadsAndRetryAllocation().

Referenced by AllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

TearDown()

void v8::internal::PagedSpace::TearDown

(

)

Definition at line 909 of file spaces.cc.

                          {
  PageIterator iterator(this);
  while (iterator.has_next()) {
    heap()->isolate()->memory_allocator()->Free(iterator.next());
  }
  anchor_.set_next_page(&anchor_);
  anchor_.set_prev_page(&anchor_);
  accounting_stats_.Clear();
}

References accounting_stats_, anchor_, v8::internal::MemoryAllocator::Free(), v8::internal::Space::heap(), v8::internal::Heap::isolate(), v8::internal::Isolate::memory_allocator(), PageIterator, v8::internal::Page::set_next_page(), and v8::internal::Page::set_prev_page().

Referenced by v8::internal::Heap::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

top()

Address v8::internal::PagedSpace::top ( )

inline

Definition at line 1751 of file spaces.h.

{ return allocation_info_.top(); }

References allocation_info_.

Referenced by v8::internal::FreeList::Allocate(), v8::internal::Deserializer::DeserializePartial(), EmptyAllocationInfo(), v8::internal::HeapObjectIterator::FromCurrentPage(), v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), SetTopAndLimit(), and SizeOfObjects().

Here is the caller graph for this function:

UseEmergencyMemory()

void v8::internal::PagedSpace::UseEmergencyMemory

(

)

Definition at line 1113 of file spaces.cc.

                                    {
  Page* page = Page::Initialize(heap(), emergency_memory_, executable(), this);
  page->InsertAfter(anchor_.prev_page());
  emergency_memory_ = NULL;
}

References anchor_, emergency_memory_, v8::internal::Space::executable(), v8::internal::Space::heap(), v8::internal::Page::Initialize(), v8::internal::MemoryChunk::InsertAfter(), NULL, and v8::internal::Page::prev_page().

Here is the call graph for this function:

WaitForSweeperThreadsAndRetryAllocation()

HeapObject * v8::internal::PagedSpace::WaitForSweeperThreadsAndRetryAllocation ( int  size_in_bytes )

protected

Definition at line 2532 of file spaces.cc.

                       {
  MarkCompactCollector* collector = heap()->mark_compact_collector();
  if (collector->sweeping_in_progress()) {
    // Wait for the sweeper threads here and complete the sweeping phase.
    collector->EnsureSweepingCompleted();
 
    // After waiting for the sweeper threads, there may be new free-list
    // entries.
    return free_list_.Allocate(size_in_bytes);
  }
  return NULL;
}

References v8::internal::FreeList::Allocate(), v8::internal::MarkCompactCollector::EnsureSweepingCompleted(), free_list_, v8::internal::Space::heap(), v8::internal::Heap::mark_compact_collector(), NULL, and v8::internal::MarkCompactCollector::sweeping_in_progress().

Referenced by SlowAllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

Waste()

virtual intptr_t v8::internal::PagedSpace::Waste ( )

inlinevirtual

Definition at line 1748 of file spaces.h.

{ return accounting_stats_.Waste(); }

References accounting_stats_.

Friends And Related Function Documentation

MarkCompactCollector

friend class MarkCompactCollector

friend

Definition at line 1937 of file spaces.h.

PageIterator

friend class PageIterator

friend

Definition at line 1936 of file spaces.h.

Referenced by CommittedPhysicalMemory(), CountTotalPages(), ResetFreeListStatistics(), and TearDown().

Member Data Documentation

accounting_stats_

AllocationStats v8::internal::PagedSpace::accounting_stats_

protected

Definition at line 1892 of file spaces.h.

Referenced by AddToAccountingStats(), Allocate(), Capacity(), ClearStats(), Free(), IncreaseCapacity(), MaximumCommittedMemory(), PagedSpace(), ReleasePage(), Size(), TearDown(), and Waste().

allocation_info_

AllocationInfo v8::internal::PagedSpace::allocation_info_

protected

Definition at line 1901 of file spaces.h.

Referenced by AllocateLinearly(), allocation_limit_address(), allocation_top_address(), CommittedPhysicalMemory(), EvictEvacuationCandidatesFromFreeLists(), limit(), PagedSpace(), ReleasePage(), SetTopAndLimit(), and top().

anchor_

Page v8::internal::PagedSpace::anchor_

protected

Definition at line 1895 of file spaces.h.

Referenced by anchor(), Expand(), FirstPage(), LastPage(), PagedSpace(), TearDown(), and UseEmergencyMemory().

area_size_

int v8::internal::PagedSpace::area_size_

protected

Definition at line 1884 of file spaces.h.

Referenced by AreaSize(), and PagedSpace().

emergency_memory_

MemoryChunk* v8::internal::PagedSpace::emergency_memory_

protected

Definition at line 1916 of file spaces.h.

Referenced by CreateEmergencyMemory(), FreeEmergencyMemory(), HasEmergencyMemory(), and UseEmergencyMemory().

end_of_unswept_pages_

Page* v8::internal::PagedSpace::end_of_unswept_pages_

protected

Definition at line 1910 of file spaces.h.

Referenced by end_of_unswept_pages(), and set_end_of_unswept_pages().

free_list_

FreeList v8::internal::PagedSpace::free_list_

protected

Definition at line 1898 of file spaces.h.

Referenced by AllocateRaw(), Available(), Free(), free_list(), FreeEmergencyMemory(), PrepareForMarkCompact(), ReleasePage(), RepairFreeListsAfterBoot(), ResetFreeList(), SlowAllocateRaw(), and WaitForSweeperThreadsAndRetryAllocation().

max_capacity_

intptr_t v8::internal::PagedSpace::max_capacity_

protected

Definition at line 1887 of file spaces.h.

Referenced by CanExpand(), Expand(), and PagedSpace().

unswept_free_bytes_

intptr_t v8::internal::PagedSpace::unswept_free_bytes_

protected

Definition at line 1905 of file spaces.h.

Referenced by DecreaseUnsweptFreeBytes(), DecrementUnsweptFreeBytes(), IncreaseUnsweptFreeBytes(), IncrementUnsweptFreeBytes(), PrepareForMarkCompact(), ResetUnsweptFreeBytes(), and SizeOfObjects().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/heap/spaces.h
• /mnt/V8SourceCode/src/heap/spaces-inl.h
• /mnt/V8SourceCode/src/heap/spaces.cc