v8::internal::SemiSpace Class Reference

#include <spaces.h>

Inheritance diagram for v8::internal::SemiSpace:

Collaboration diagram for v8::internal::SemiSpace:

Public Member Functions
	SemiSpace (Heap *heap, SemiSpaceId semispace)
void	SetUp (Address start, int initial_capacity, int maximum_capacity)
void	TearDown ()
bool	HasBeenSetUp ()
bool	GrowTo (int new_capacity)
bool	ShrinkTo (int new_capacity)
Address	space_start ()
Address	page_low ()
Address	space_end ()
Address	page_high ()
bool	AdvancePage ()
void	Reset ()
Address	age_mark ()
void	set_age_mark (Address mark)
bool	Contains (Address a)
bool	Contains (Object *o)
virtual intptr_t	Size ()
bool	is_committed ()
bool	Commit ()
bool	Uncommit ()
NewSpacePage *	first_page ()
NewSpacePage *	current_page ()
int	TotalCapacity ()
int	MaximumTotalCapacity ()
int	InitialTotalCapacity ()
SemiSpaceId	id ()
size_t	MaximumCommittedMemory ()
size_t	CommittedPhysicalMemory ()
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 intptr_t	SizeOfObjects ()
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 void	AssertValidRange (Address from, Address to)
static void	Swap (SemiSpace *from, SemiSpace *to)
Static Public Member Functions inherited from v8::internal::Malloced
static void	FatalProcessOutOfMemory ()
static void *	New (size_t size)
static void	Delete (void *p)

Private Member Functions
void	FlipPages (intptr_t flags, intptr_t flag_mask)
void	SetCapacity (int new_capacity)
NewSpacePage *	anchor ()

Private Attributes
int	total_capacity_
int	maximum_total_capacity_
int	initial_total_capacity_
intptr_t	maximum_committed_
Address	start_
Address	age_mark_
uintptr_t	address_mask_
uintptr_t	object_mask_
uintptr_t	object_expected_
bool	committed_
SemiSpaceId	id_
NewSpacePage	anchor_
NewSpacePage *	current_page_

Friends
class	SemiSpaceIterator
class	NewSpacePageIterator

Detailed Description

Definition at line 2066 of file spaces.h.

Constructor & Destructor Documentation

SemiSpace()

v8::internal::SemiSpace::SemiSpace ( Heap *  heap, SemiSpaceId  semispace  )

inline

Definition at line 2069 of file spaces.h.

      : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
        start_(NULL),
        age_mark_(NULL),
        id_(semispace),
        anchor_(this),
        current_page_(NULL) {}

Member Function Documentation

AdvancePage()

bool v8::internal::SemiSpace::AdvancePage ( )

inline

Definition at line 2112 of file spaces.h.

                     {
    NewSpacePage* next_page = current_page_->next_page();
    if (next_page == anchor()) return false;
    current_page_ = next_page;
    return true;
  }

References anchor(), current_page_, and v8::internal::NewSpacePage::next_page().

Referenced by v8::internal::NewSpace::AddFreshPage().

Here is the call graph for this function:

Here is the caller graph for this function:

age_mark()

Address v8::internal::SemiSpace::age_mark ( )

inline

Definition at line 2123 of file spaces.h.

{ return age_mark_; }

References age_mark_.

Referenced by v8::internal::NewSpace::age_mark().

Here is the caller graph for this function:

anchor()

NewSpacePage* v8::internal::SemiSpace::anchor ( )

inlineprivate

Definition at line 2195 of file spaces.h.

{ return &anchor_; }

References anchor_.

Referenced by AdvancePage(), Commit(), GrowTo(), ShrinkTo(), and Uncommit().

Here is the caller graph for this function:

AssertValidRange()

static void v8::internal::SemiSpace::AssertValidRange ( Address  from, Address  to  )

inlinestatic

Definition at line 2165 of file spaces.h.

{}

Referenced by v8::internal::Heap::DoScavenge(), v8::internal::SemiSpaceIterator::Initialize(), v8::internal::PromotionQueue::insert(), and v8::internal::PromotionQueue::remove().

Here is the caller graph for this function:

Commit()

bool v8::internal::SemiSpace::Commit

(

)

Definition at line 1488 of file spaces.cc.

                       {
  DCHECK(!is_committed());
  int pages = total_capacity_ / Page::kPageSize;
  if (!heap()->isolate()->memory_allocator()->CommitBlock(
          start_, total_capacity_, executable())) {
    return false;
  }
 
  NewSpacePage* current = anchor();
  for (int i = 0; i < pages; i++) {
    NewSpacePage* new_page =
        NewSpacePage::Initialize(heap(), start_ + i * Page::kPageSize, this);
    new_page->InsertAfter(current);
    current = new_page;
  }
 
  SetCapacity(total_capacity_);
  committed_ = true;
  Reset();
  return true;
}

References anchor(), committed_, DCHECK, v8::internal::Space::executable(), v8::internal::Space::heap(), v8::internal::NewSpacePage::Initialize(), v8::internal::MemoryChunk::InsertAfter(), is_committed(), v8::internal::Page::kPageSize, Reset(), SetCapacity(), start_, and total_capacity_.

Referenced by v8::internal::NewSpace::CommitFromSpaceIfNeeded(), GrowTo(), and v8::internal::NewSpace::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

CommittedPhysicalMemory()

size_t v8::internal::SemiSpace::CommittedPhysicalMemory

(

)

Definition at line 1526 of file spaces.cc.

                                          {
  if (!is_committed()) return 0;
  size_t size = 0;
  NewSpacePageIterator it(this);
  while (it.has_next()) {
    size += it.next()->CommittedPhysicalMemory();
  }
  return size;
}

References is_committed(), NewSpacePageIterator, and size.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Contains() [1/2]

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

inline

Definition at line 2128 of file spaces.h.

                           {
    return (reinterpret_cast<uintptr_t>(a) & address_mask_) ==
           reinterpret_cast<uintptr_t>(start_);
  }

References address_mask_, and start_.

Referenced by v8::internal::NewSpace::FromSpaceContains(), and v8::internal::NewSpace::ToSpaceContains().

Here is the caller graph for this function:

Contains() [2/2]

bool v8::internal::SemiSpace::Contains ( Object *  o )

inline

Definition at line 2135 of file spaces.h.

                           {
    return (reinterpret_cast<uintptr_t>(o) & object_mask_) == object_expected_;
  }

References object_expected_, and object_mask_.

current_page()

NewSpacePage* v8::internal::SemiSpace::current_page ( )

inline

Definition at line 2151 of file spaces.h.

{ return current_page_; }

References current_page_.

Referenced by v8::internal::NewSpace::limit(), v8::internal::NewSpace::set_top(), Swap(), and v8::internal::NewSpace::top().

Here is the caller graph for this function:

first_page()

NewSpacePage* v8::internal::SemiSpace::first_page ( )

inline

Definition at line 2150 of file spaces.h.

{ return anchor_.next_page(); }

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

Referenced by ShrinkTo().

Here is the call graph for this function:

Here is the caller graph for this function:

FlipPages()

void v8::internal::SemiSpace::FlipPages ( intptr_t  flags, intptr_t  flag_mask  )

private

Definition at line 1599 of file spaces.cc.

                                                       {
  anchor_.set_owner(this);
  // Fixup back-pointers to anchor. Address of anchor changes
  // when we swap.
  anchor_.prev_page()->set_next_page(&anchor_);
  anchor_.next_page()->set_prev_page(&anchor_);
 
  bool becomes_to_space = (id_ == kFromSpace);
  id_ = becomes_to_space ? kToSpace : kFromSpace;
  NewSpacePage* page = anchor_.next_page();
  while (page != &anchor_) {
    page->set_owner(this);
    page->SetFlags(flags, mask);
    if (becomes_to_space) {
      page->ClearFlag(MemoryChunk::IN_FROM_SPACE);
      page->SetFlag(MemoryChunk::IN_TO_SPACE);
      page->ClearFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
      page->ResetLiveBytes();
    } else {
      page->SetFlag(MemoryChunk::IN_FROM_SPACE);
      page->ClearFlag(MemoryChunk::IN_TO_SPACE);
    }
    DCHECK(page->IsFlagSet(MemoryChunk::SCAN_ON_SCAVENGE));
    DCHECK(page->IsFlagSet(MemoryChunk::IN_TO_SPACE) ||
           page->IsFlagSet(MemoryChunk::IN_FROM_SPACE));
    page = page->next_page();
  }
}

References anchor_, v8::internal::MemoryChunk::ClearFlag(), DCHECK, v8::internal::anonymous_namespace{flags.cc}::flags, id_, v8::internal::MemoryChunk::IN_FROM_SPACE, v8::internal::MemoryChunk::IN_TO_SPACE, v8::internal::MemoryChunk::IsFlagSet(), v8::internal::kFromSpace, v8::internal::kToSpace, v8::internal::MemoryChunk::NEW_SPACE_BELOW_AGE_MARK, v8::internal::NewSpacePage::next_page(), v8::internal::NewSpacePage::prev_page(), v8::internal::MemoryChunk::ResetLiveBytes(), v8::internal::MemoryChunk::SCAN_ON_SCAVENGE, v8::internal::NewSpacePage::set_next_page(), v8::internal::MemoryChunk::set_owner(), v8::internal::NewSpacePage::set_prev_page(), v8::internal::MemoryChunk::SetFlag(), and v8::internal::MemoryChunk::SetFlags().

Referenced by Swap().

Here is the call graph for this function:

Here is the caller graph for this function:

GrowTo()

bool v8::internal::SemiSpace::GrowTo

(

int

new_capacity

)

Definition at line 1537 of file spaces.cc.

                                       {
  if (!is_committed()) {
    if (!Commit()) return false;
  }
  DCHECK((new_capacity & Page::kPageAlignmentMask) == 0);
  DCHECK(new_capacity <= maximum_total_capacity_);
  DCHECK(new_capacity > total_capacity_);
  int pages_before = total_capacity_ / Page::kPageSize;
  int pages_after = new_capacity / Page::kPageSize;
 
  size_t delta = new_capacity - total_capacity_;
 
  DCHECK(IsAligned(delta, base::OS::AllocateAlignment()));
  if (!heap()->isolate()->memory_allocator()->CommitBlock(
          start_ + total_capacity_, delta, executable())) {
    return false;
  }
  SetCapacity(new_capacity);
  NewSpacePage* last_page = anchor()->prev_page();
  DCHECK(last_page != anchor());
  for (int i = pages_before; i < pages_after; i++) {
    Address page_address = start_ + i * Page::kPageSize;
    NewSpacePage* new_page =
        NewSpacePage::Initialize(heap(), page_address, this);
    new_page->InsertAfter(last_page);
    Bitmap::Clear(new_page);
    // Duplicate the flags that was set on the old page.
    new_page->SetFlags(last_page->GetFlags(),
                       NewSpacePage::kCopyOnFlipFlagsMask);
    last_page = new_page;
  }
  return true;
}

References v8::base::OS::AllocateAlignment(), anchor(), v8::internal::Bitmap::Clear(), Commit(), DCHECK, v8::internal::Space::executable(), v8::internal::MemoryChunk::GetFlags(), v8::internal::Space::heap(), v8::internal::NewSpacePage::Initialize(), v8::internal::MemoryChunk::InsertAfter(), is_committed(), v8::internal::IsAligned(), v8::internal::NewSpacePage::kCopyOnFlipFlagsMask, v8::internal::Page::kPageAlignmentMask, v8::internal::Page::kPageSize, maximum_total_capacity_, v8::internal::NewSpacePage::prev_page(), SetCapacity(), v8::internal::MemoryChunk::SetFlags(), start_, and total_capacity_.

Referenced by v8::internal::NewSpace::Grow(), and v8::internal::NewSpace::Shrink().

Here is the call graph for this function:

Here is the caller graph for this function:

HasBeenSetUp()

bool v8::internal::SemiSpace::HasBeenSetUp ( )

inline

Definition at line 2085 of file spaces.h.

{ return start_ != NULL; }

References NULL, and start_.

Referenced by v8::internal::NewSpace::HasBeenSetUp().

Here is the caller graph for this function:

id()

SemiSpaceId v8::internal::SemiSpace::id ( )

inline

Definition at line 2177 of file spaces.h.

{ return id_; }

References id_.

Referenced by v8::internal::NewSpacePage::Initialize().

Here is the caller graph for this function:

InitialTotalCapacity()

int v8::internal::SemiSpace::InitialTotalCapacity ( )

inline

Definition at line 2175 of file spaces.h.

{ return initial_total_capacity_; }

References initial_total_capacity_.

Referenced by v8::internal::NewSpace::InitialTotalCapacity().

Here is the caller graph for this function:

is_committed()

bool v8::internal::SemiSpace::is_committed ( )

inline

Definition at line 2146 of file spaces.h.

{ return committed_; }

References committed_.

Referenced by Commit(), v8::internal::NewSpace::CommitFromSpaceIfNeeded(), v8::internal::NewSpace::CommittedMemory(), CommittedPhysicalMemory(), v8::internal::NewSpace::CommittedPhysicalMemory(), GrowTo(), v8::internal::NewSpace::SetUp(), ShrinkTo(), Uncommit(), and v8::internal::NewSpace::UncommitFromSpace().

Here is the caller graph for this function:

MaximumCommittedMemory()

size_t v8::internal::SemiSpace::MaximumCommittedMemory ( )

inline

Definition at line 2182 of file spaces.h.

{ return maximum_committed_; }

References maximum_committed_.

Referenced by v8::internal::NewSpace::MaximumCommittedMemory().

Here is the caller graph for this function:

MaximumTotalCapacity()

int v8::internal::SemiSpace::MaximumTotalCapacity ( )

inline

Definition at line 2172 of file spaces.h.

{ return maximum_total_capacity_; }

References maximum_total_capacity_.

Referenced by v8::internal::NewSpace::MaximumCapacity().

Here is the caller graph for this function:

page_high()

Address v8::internal::SemiSpace::page_high ( )

inline

Definition at line 2110 of file spaces.h.

{ return current_page_->area_end(); }

References v8::internal::MemoryChunk::area_end(), and current_page_.

Referenced by v8::internal::NewSpace::FromSpacePageHigh(), v8::internal::NewSpace::SlowAllocateRaw(), v8::internal::NewSpace::UpdateAllocationInfo(), and v8::internal::NewSpace::UpdateInlineAllocationLimit().

Here is the call graph for this function:

Here is the caller graph for this function:

page_low()

Address v8::internal::SemiSpace::page_low ( )

inline

Definition at line 2104 of file spaces.h.

{ return current_page_->area_start(); }

References v8::internal::MemoryChunk::area_start(), and current_page_.

Referenced by v8::internal::NewSpace::FromSpacePageLow(), v8::internal::NewSpace::Size(), v8::internal::NewSpace::SlowAllocateRaw(), and v8::internal::NewSpace::UpdateAllocationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

Reset()

void v8::internal::SemiSpace::Reset

(

)

Definition at line 1629 of file spaces.cc.

                      {
  DCHECK(anchor_.next_page() != &anchor_);
  current_page_ = anchor_.next_page();
}

References anchor_, current_page_, DCHECK, and v8::internal::NewSpacePage::next_page().

Referenced by Commit(), v8::internal::NewSpace::ResetAllocationInfo(), and v8::internal::NewSpace::Shrink().

Here is the call graph for this function:

Here is the caller graph for this function:

set_age_mark()

void v8::internal::SemiSpace::set_age_mark

(

Address

mark

)

Definition at line 1664 of file spaces.cc.

                                         {
  DCHECK(NewSpacePage::FromLimit(mark)->semi_space() == this);
  age_mark_ = mark;
  // Mark all pages up to the one containing mark.
  NewSpacePageIterator it(space_start(), mark);
  while (it.has_next()) {
    it.next()->SetFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
  }
}

References age_mark_, DCHECK, v8::internal::NewSpacePage::FromLimit(), v8::internal::MemoryChunk::NEW_SPACE_BELOW_AGE_MARK, NewSpacePageIterator, and space_start().

Referenced by v8::internal::NewSpace::set_age_mark().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCapacity()

void v8::internal::SemiSpace::SetCapacity ( int  new_capacity )

private

Definition at line 1656 of file spaces.cc.

                                            {
  total_capacity_ = new_capacity;
  if (total_capacity_ > maximum_committed_) {
    maximum_committed_ = total_capacity_;
  }
}

References maximum_committed_, and total_capacity_.

Referenced by Commit(), GrowTo(), and ShrinkTo().

Here is the caller graph for this function:

SetUp()

void v8::internal::SemiSpace::SetUp	(	Address	start,
		int	initial_capacity,
		int	maximum_capacity
	)

Definition at line 1460 of file spaces.cc.

                                            {
  // Creates a space in the young generation. The constructor does not
  // allocate memory from the OS.  A SemiSpace is given a contiguous chunk of
  // memory of size 'capacity' when set up, and does not grow or shrink
  // otherwise.  In the mark-compact collector, the memory region of the from
  // space is used as the marking stack. It requires contiguous memory
  // addresses.
  DCHECK(maximum_capacity >= Page::kPageSize);
  initial_total_capacity_ = RoundDown(initial_capacity, Page::kPageSize);
  total_capacity_ = initial_capacity;
  maximum_total_capacity_ = RoundDown(maximum_capacity, Page::kPageSize);
  maximum_committed_ = 0;
  committed_ = false;
  start_ = start;
  address_mask_ = ~(maximum_capacity - 1);
  object_mask_ = address_mask_ | kHeapObjectTagMask;
  object_expected_ = reinterpret_cast<uintptr_t>(start) | kHeapObjectTag;
  age_mark_ = start_;
}

References address_mask_, age_mark_, committed_, DCHECK, initial_total_capacity_, v8::internal::kHeapObjectTag, v8::internal::kHeapObjectTagMask, v8::internal::Page::kPageSize, maximum_committed_, maximum_total_capacity_, object_expected_, object_mask_, RoundDown(), start_, and total_capacity_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ShrinkTo()

bool v8::internal::SemiSpace::ShrinkTo

(

int

new_capacity

)

Definition at line 1572 of file spaces.cc.

                                         {
  DCHECK((new_capacity & Page::kPageAlignmentMask) == 0);
  DCHECK(new_capacity >= initial_total_capacity_);
  DCHECK(new_capacity < total_capacity_);
  if (is_committed()) {
    size_t delta = total_capacity_ - new_capacity;
    DCHECK(IsAligned(delta, base::OS::AllocateAlignment()));
 
    MemoryAllocator* allocator = heap()->isolate()->memory_allocator();
    if (!allocator->UncommitBlock(start_ + new_capacity, delta)) {
      return false;
    }
 
    int pages_after = new_capacity / Page::kPageSize;
    NewSpacePage* new_last_page =
        NewSpacePage::FromAddress(start_ + (pages_after - 1) * Page::kPageSize);
    new_last_page->set_next_page(anchor());
    anchor()->set_prev_page(new_last_page);
    DCHECK((current_page_ >= first_page()) && (current_page_ <= new_last_page));
  }
 
  SetCapacity(new_capacity);
 
  return true;
}

References v8::base::OS::AllocateAlignment(), anchor(), current_page_, DCHECK, first_page(), v8::internal::NewSpacePage::FromAddress(), v8::internal::Space::heap(), initial_total_capacity_, is_committed(), v8::internal::IsAligned(), v8::internal::Heap::isolate(), v8::internal::Page::kPageAlignmentMask, v8::internal::Page::kPageSize, v8::internal::Isolate::memory_allocator(), v8::internal::NewSpacePage::set_next_page(), v8::internal::NewSpacePage::set_prev_page(), SetCapacity(), start_, total_capacity_, and v8::internal::MemoryAllocator::UncommitBlock().

Referenced by v8::internal::NewSpace::Grow(), and v8::internal::NewSpace::Shrink().

Here is the call graph for this function:

Here is the caller graph for this function:

Size()

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

inlinevirtual

Implements v8::internal::Space.

Definition at line 2141 of file spaces.h.

                          {
    UNREACHABLE();
    return 0;
  }

References UNREACHABLE.

space_end()

Address v8::internal::SemiSpace::space_end ( )

inline

Definition at line 2107 of file spaces.h.

{ return anchor_.prev_page()->area_end(); }

References anchor_, v8::internal::MemoryChunk::area_end(), and v8::internal::NewSpacePage::prev_page().

Referenced by v8::internal::NewSpace::FromSpaceEnd(), and v8::internal::NewSpace::ToSpaceEnd().

Here is the call graph for this function:

Here is the caller graph for this function:

space_start()

Address v8::internal::SemiSpace::space_start ( )

inline

Definition at line 2098 of file spaces.h.

                        {
    DCHECK(anchor_.next_page() != &anchor_);
    return anchor_.next_page()->area_start();
  }

References anchor_, v8::internal::MemoryChunk::area_start(), DCHECK, and v8::internal::NewSpacePage::next_page().

Referenced by v8::internal::NewSpace::bottom(), v8::internal::NewSpace::FromSpaceStart(), set_age_mark(), and v8::internal::NewSpace::ToSpaceStart().

Here is the call graph for this function:

Here is the caller graph for this function:

Swap()

void v8::internal::SemiSpace::Swap ( SemiSpace *  from, SemiSpace *  to  )

static

Definition at line 1635 of file spaces.cc.

                                                   {
  // We won't be swapping semispaces without data in them.
  DCHECK(from->anchor_.next_page() != &from->anchor_);
  DCHECK(to->anchor_.next_page() != &to->anchor_);
 
  // Swap bits.
  SemiSpace tmp = *from;
  *from = *to;
  *to = tmp;
 
  // Fixup back-pointers to the page list anchor now that its address
  // has changed.
  // Swap to/from-space bits on pages.
  // Copy GC flags from old active space (from-space) to new (to-space).
  intptr_t flags = from->current_page()->GetFlags();
  to->FlipPages(flags, NewSpacePage::kCopyOnFlipFlagsMask);
 
  from->FlipPages(0, 0);
}

References anchor_, current_page(), DCHECK, v8::internal::anonymous_namespace{flags.cc}::flags, FlipPages(), v8::internal::MemoryChunk::GetFlags(), v8::internal::NewSpacePage::kCopyOnFlipFlagsMask, v8::internal::NewSpacePage::next_page(), and to().

Referenced by v8::internal::NewSpace::Flip().

Here is the call graph for this function:

Here is the caller graph for this function:

TearDown()

void v8::internal::SemiSpace::TearDown

(

)

Definition at line 1482 of file spaces.cc.

                         {
  start_ = NULL;
  total_capacity_ = 0;
}

References NULL, start_, and total_capacity_.

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

Here is the caller graph for this function:

TotalCapacity()

int v8::internal::SemiSpace::TotalCapacity ( )

inline

Definition at line 2169 of file spaces.h.

{ return total_capacity_; }

References total_capacity_.

Referenced by v8::internal::NewSpace::Capacity(), v8::internal::NewSpace::Grow(), v8::internal::NewSpace::Shrink(), and v8::internal::NewSpace::TotalCapacity().

Here is the caller graph for this function:

Uncommit()

bool v8::internal::SemiSpace::Uncommit

(

)

Definition at line 1511 of file spaces.cc.

                         {
  DCHECK(is_committed());
  Address start = start_ + maximum_total_capacity_ - total_capacity_;
  if (!heap()->isolate()->memory_allocator()->UncommitBlock(start,
                                                            total_capacity_)) {
    return false;
  }
  anchor()->set_next_page(anchor());
  anchor()->set_prev_page(anchor());
 
  committed_ = false;
  return true;
}

References anchor(), committed_, DCHECK, v8::internal::Space::heap(), is_committed(), maximum_total_capacity_, v8::internal::NewSpacePage::set_next_page(), v8::internal::NewSpacePage::set_prev_page(), start_, and total_capacity_.

Referenced by v8::internal::NewSpace::UncommitFromSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

NewSpacePageIterator

friend class NewSpacePageIterator

friend

Definition at line 2221 of file spaces.h.

Referenced by CommittedPhysicalMemory(), and set_age_mark().

SemiSpaceIterator

friend class SemiSpaceIterator

friend

Definition at line 2220 of file spaces.h.

Member Data Documentation

address_mask_

uintptr_t v8::internal::SemiSpace::address_mask_

private

Definition at line 2210 of file spaces.h.

Referenced by Contains(), and SetUp().

age_mark_

Address v8::internal::SemiSpace::age_mark_

private

Definition at line 2207 of file spaces.h.

Referenced by age_mark(), set_age_mark(), and SetUp().

anchor_

NewSpacePage v8::internal::SemiSpace::anchor_

private

Definition at line 2217 of file spaces.h.

Referenced by anchor(), first_page(), FlipPages(), Reset(), space_end(), space_start(), and Swap().

committed_

bool v8::internal::SemiSpace::committed_

private

Definition at line 2214 of file spaces.h.

Referenced by Commit(), is_committed(), SetUp(), and Uncommit().

current_page_

NewSpacePage* v8::internal::SemiSpace::current_page_

private

Definition at line 2218 of file spaces.h.

Referenced by AdvancePage(), current_page(), page_high(), page_low(), Reset(), and ShrinkTo().

id_

SemiSpaceId v8::internal::SemiSpace::id_

private

Definition at line 2215 of file spaces.h.

Referenced by FlipPages(), and id().

initial_total_capacity_

int v8::internal::SemiSpace::initial_total_capacity_

private

Definition at line 2200 of file spaces.h.

Referenced by InitialTotalCapacity(), SetUp(), and ShrinkTo().

maximum_committed_

intptr_t v8::internal::SemiSpace::maximum_committed_

private

Definition at line 2202 of file spaces.h.

Referenced by MaximumCommittedMemory(), SetCapacity(), and SetUp().

maximum_total_capacity_

int v8::internal::SemiSpace::maximum_total_capacity_

private

Definition at line 2199 of file spaces.h.

Referenced by GrowTo(), MaximumTotalCapacity(), SetUp(), and Uncommit().

object_expected_

uintptr_t v8::internal::SemiSpace::object_expected_

private

Definition at line 2212 of file spaces.h.

Referenced by Contains(), and SetUp().

object_mask_

uintptr_t v8::internal::SemiSpace::object_mask_

private

Definition at line 2211 of file spaces.h.

Referenced by Contains(), and SetUp().

start_

Address v8::internal::SemiSpace::start_

private

Definition at line 2205 of file spaces.h.

Referenced by Commit(), Contains(), GrowTo(), HasBeenSetUp(), SetUp(), ShrinkTo(), TearDown(), and Uncommit().

total_capacity_

int v8::internal::SemiSpace::total_capacity_

private

Definition at line 2198 of file spaces.h.

Referenced by Commit(), GrowTo(), SetCapacity(), SetUp(), ShrinkTo(), TearDown(), TotalCapacity(), and Uncommit().

---

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

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