v8::internal::MemoryChunk Class Reference

#include <spaces.h>

Inheritance diagram for v8::internal::MemoryChunk:

Collaboration diagram for v8::internal::MemoryChunk:

Public Types
enum	MemoryChunkFlags {   IS_EXECUTABLE , ABOUT_TO_BE_FREED , POINTERS_TO_HERE_ARE_INTERESTING , POINTERS_FROM_HERE_ARE_INTERESTING ,   SCAN_ON_SCAVENGE , IN_FROM_SPACE , IN_TO_SPACE , NEW_SPACE_BELOW_AGE_MARK ,   CONTAINS_ONLY_DATA , EVACUATION_CANDIDATE , RESCAN_ON_EVACUATION , WAS_SWEPT ,   HAS_PROGRESS_BAR , NUM_MEMORY_CHUNK_FLAGS }
enum	ParallelSweepingState { SWEEPING_DONE , SWEEPING_FINALIZE , SWEEPING_IN_PROGRESS , SWEEPING_PENDING }

Public Member Functions
Address	address ()
bool	is_valid ()
MemoryChunk *	next_chunk () const
MemoryChunk *	prev_chunk () const
void	set_next_chunk (MemoryChunk *next)
void	set_prev_chunk (MemoryChunk *prev)
Space *	owner () const
void	set_owner (Space *space)
base::VirtualMemory *	reserved_memory ()
void	InitializeReservedMemory ()
void	set_reserved_memory (base::VirtualMemory *reservation)
bool	scan_on_scavenge ()
void	initialize_scan_on_scavenge (bool scan)
void	set_scan_on_scavenge (bool scan)
int	store_buffer_counter ()
void	set_store_buffer_counter (int counter)
bool	Contains (Address addr)
bool	ContainsLimit (Address addr)
void	SetFlag (int flag)
void	ClearFlag (int flag)
void	SetFlagTo (int flag, bool value)
bool	IsFlagSet (int flag)
void	SetFlags (intptr_t flags, intptr_t mask)
intptr_t	GetFlags ()
ParallelSweepingState	parallel_sweeping ()
void	set_parallel_sweeping (ParallelSweepingState state)
bool	TryParallelSweeping ()
bool	SweepingCompleted ()
void	ResetLiveBytes ()
void	IncrementLiveBytes (int by)
int	LiveBytes ()
int	write_barrier_counter ()
void	set_write_barrier_counter (int counter)
int	progress_bar ()
void	set_progress_bar (int progress_bar)
void	ResetProgressBar ()
bool	IsLeftOfProgressBar (Object **slot)
size_t	size () const
void	set_size (size_t size)
void	SetArea (Address area_start, Address area_end)
Executability	executable ()
bool	ContainsOnlyData ()
bool	InNewSpace ()
bool	InToSpace ()
bool	InFromSpace ()
Bitmap *	markbits ()
void	PrintMarkbits ()
uint32_t	AddressToMarkbitIndex (Address addr)
Address	MarkbitIndexToAddress (uint32_t index)
void	InsertAfter (MemoryChunk *other)
void	Unlink ()
Heap *	heap () const
bool	IsEvacuationCandidate ()
bool	ShouldSkipEvacuationSlotRecording ()
SkipList *	skip_list ()
void	set_skip_list (SkipList *skip_list)
SlotsBuffer *	slots_buffer ()
SlotsBuffer **	slots_buffer_address ()
void	MarkEvacuationCandidate ()
void	ClearEvacuationCandidate ()
Address	area_start ()
Address	area_end ()
int	area_size ()
bool	CommitArea (size_t requested)
size_t	CommittedPhysicalMemory ()

Static Public Member Functions
static MemoryChunk *	FromAddress (Address a)
static const MemoryChunk *	FromAddress (const byte *a)
static MemoryChunk *	FromAnyPointerAddress (Heap *heap, Address addr)
static void	IncrementLiveBytesFromGC (Address address, int by)
static void	IncrementLiveBytesFromMutator (Address address, int by)
static uint32_t	FastAddressToMarkbitIndex (Address addr)
static void	UpdateHighWaterMark (Address mark)

Static Public Attributes
static const int	kWriteBarrierCounterGranularity = 500
static const int	kPointersToHereAreInterestingMask
static const int	kPointersFromHereAreInterestingMask
static const int	kEvacuationCandidateMask = 1 << EVACUATION_CANDIDATE
static const int	kSkipEvacuationSlotsRecordingMask
static const intptr_t	kAlignment
static const intptr_t	kAlignmentMask = kAlignment - 1
static const intptr_t	kSizeOffset = 0
static const intptr_t	kLiveBytesOffset
static const size_t	kSlotsBufferOffset = kLiveBytesOffset + kIntSize
static const size_t	kWriteBarrierCounterOffset
static const size_t	kHeaderSize
static const int	kBodyOffset
static const int	kObjectStartAlignment = 32 * kPointerSize
static const int	kObjectStartOffset
static const int	kFlagsOffset = kPointerSize

Static Protected Member Functions
static MemoryChunk *	Initialize (Heap *heap, Address base, size_t size, Address area_start, Address area_end, Executability executable, Space *owner)

Protected Attributes
size_t	size_
intptr_t	flags_
Address	area_start_
Address	area_end_
base::VirtualMemory	reservation_
Address	owner_
Heap *	heap_
int	store_buffer_counter_
int	live_byte_count_
SlotsBuffer *	slots_buffer_
SkipList *	skip_list_
intptr_t	write_barrier_counter_
int	progress_bar_
int	high_water_mark_
base::AtomicWord	parallel_sweeping_
intptr_t	available_in_small_free_list_
intptr_t	available_in_medium_free_list_
intptr_t	available_in_large_free_list_
intptr_t	available_in_huge_free_list_
intptr_t	non_available_small_blocks_

Private Attributes
base::AtomicWord	next_chunk_
base::AtomicWord	prev_chunk_

Friends
class	MemoryAllocator

Detailed Description

Definition at line 273 of file spaces.h.

Member Enumeration Documentation

MemoryChunkFlags

enum v8::internal::MemoryChunk::MemoryChunkFlags

Enumerator
IS_EXECUTABLE
ABOUT_TO_BE_FREED
POINTERS_TO_HERE_ARE_INTERESTING
POINTERS_FROM_HERE_ARE_INTERESTING
SCAN_ON_SCAVENGE
IN_FROM_SPACE
IN_TO_SPACE
NEW_SPACE_BELOW_AGE_MARK
CONTAINS_ONLY_DATA
EVACUATION_CANDIDATE
RESCAN_ON_EVACUATION
WAS_SWEPT
HAS_PROGRESS_BAR
NUM_MEMORY_CHUNK_FLAGS

Definition at line 364 of file spaces.h.

                        {
    IS_EXECUTABLE,
    ABOUT_TO_BE_FREED,
    POINTERS_TO_HERE_ARE_INTERESTING,
    POINTERS_FROM_HERE_ARE_INTERESTING,
    SCAN_ON_SCAVENGE,
    IN_FROM_SPACE,  // Mutually exclusive with IN_TO_SPACE.
    IN_TO_SPACE,    // All pages in new space has one of these two set.
    NEW_SPACE_BELOW_AGE_MARK,
    CONTAINS_ONLY_DATA,
    EVACUATION_CANDIDATE,
    RESCAN_ON_EVACUATION,
 
    // WAS_SWEPT indicates that marking bits have been cleared by the sweeper,
    // otherwise marking bits are still intact.
    WAS_SWEPT,
 
    // Large objects can have a progress bar in their page header. These object
    // are scanned in increments and will be kept black while being scanned.
    // Even if the mutator writes to them they will be kept black and a white
    // to grey transition is performed in the value.
    HAS_PROGRESS_BAR,
 
    // Last flag, keep at bottom.
    NUM_MEMORY_CHUNK_FLAGS
  };

ParallelSweepingState

enum v8::internal::MemoryChunk::ParallelSweepingState

Enumerator
SWEEPING_DONE
SWEEPING_FINALIZE
SWEEPING_IN_PROGRESS
SWEEPING_PENDING

Definition at line 438 of file spaces.h.

                             {
    SWEEPING_DONE,
    SWEEPING_FINALIZE,
    SWEEPING_IN_PROGRESS,
    SWEEPING_PENDING
  };

Member Function Documentation

address()

Address v8::internal::MemoryChunk::address ( )

inline

Definition at line 287 of file spaces.h.

{ return reinterpret_cast<Address>(this); }

Referenced by AddressToMarkbitIndex(), CommitArea(), v8::internal::MemoryAllocator::Free(), v8::internal::Heap::FreeQueuedChunks(), IncrementLiveBytesFromGC(), IncrementLiveBytesFromMutator(), Initialize(), v8::internal::Page::INLINE(), is_valid(), IsLeftOfProgressBar(), MarkbitIndexToAddress(), markbits(), v8::internal::Page::OffsetToAddress(), v8::internal::LargeObjectSpace::TearDown(), v8::internal::Heap::UpdateAllocationsHash(), and UpdateHighWaterMark().

Here is the caller graph for this function:

AddressToMarkbitIndex()

uint32_t v8::internal::MemoryChunk::AddressToMarkbitIndex ( Address  addr )

inline

Definition at line 586 of file spaces.h.

                                                      {
    return static_cast<uint32_t>(addr - this->address()) >> kPointerSizeLog2;
  }

References address(), and v8::internal::kPointerSizeLog2.

Here is the call graph for this function:

area_end()

Address v8::internal::MemoryChunk::area_end ( )

inline

Definition at line 632 of file spaces.h.

{ return area_end_; }

References area_end_.

Referenced by v8::internal::NewSpace::AddFreshPage(), v8::internal::HeapObjectIterator::AdvanceToNextPage(), area_size(), CommitArea(), Contains(), ContainsLimit(), v8::internal::Deserializer::FlushICacheForNewCodeObjects(), v8::internal::HeapObjectIterator::HeapObjectIterator(), Initialize(), v8::internal::NewSpacePage::Initialize(), v8::internal::PromotionQueue::insert(), v8::internal::SemiSpace::page_high(), v8::internal::PromotionQueue::RelocateQueueHead(), v8::internal::PromotionQueue::remove(), SetArea(), v8::internal::SemiSpace::space_end(), v8::internal::Sweep(), and v8::internal::Heap::ZapFromSpace().

Here is the caller graph for this function:

area_size()

int v8::internal::MemoryChunk::area_size ( )

inline

Definition at line 633 of file spaces.h.

{ return static_cast<int>(area_end() - area_start()); }

References area_end(), and area_start().

Referenced by v8::internal::LargeObjectSpace::AllocateRaw(), v8::internal::MarkCompactCollector::CollectEvacuationCandidates(), v8::internal::PagedSpace::DecreaseUnsweptFreeBytes(), v8::internal::PagedSpace::FreeEmergencyMemory(), v8::internal::PagedSpace::IncreaseUnsweptFreeBytes(), v8::internal::Page::Initialize(), v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates(), and v8::internal::PagedSpace::ReleasePage().

Here is the call graph for this function:

Here is the caller graph for this function:

area_start()

Address v8::internal::MemoryChunk::area_start ( )

inline

Definition at line 631 of file spaces.h.

{ return area_start_; }

References area_start_.

Referenced by v8::internal::HeapObjectIterator::AdvanceToNextPage(), area_size(), CommitArea(), Contains(), ContainsLimit(), v8::internal::Heap::DoScavenge(), v8::internal::Deoptimizer::EnsureCodeForDeoptimizationEntry(), v8::internal::Deserializer::FlushICacheForNewCodeObjects(), v8::internal::Deoptimizer::GetDeoptimizationEntry(), v8::internal::Deoptimizer::GetDeoptimizationId(), v8::internal::LargePage::GetObject(), v8::internal::HeapObjectIterator::HeapObjectIterator(), Initialize(), v8::internal::NewSpacePage::Initialize(), v8::internal::Page::Initialize(), v8::internal::SemiSpaceIterator::Next(), v8::internal::SemiSpace::page_low(), v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates(), SetArea(), v8::internal::SemiSpace::space_start(), v8::internal::Sweep(), and v8::internal::Heap::ZapFromSpace().

Here is the caller graph for this function:

ClearEvacuationCandidate()

void v8::internal::MemoryChunk::ClearEvacuationCandidate ( )

inline

Definition at line 626 of file spaces.h.

                                  {
    DCHECK(slots_buffer_ == NULL);
    ClearFlag(EVACUATION_CANDIDATE);
  }

References ClearFlag(), DCHECK, EVACUATION_CANDIDATE, NULL, and slots_buffer_.

Referenced by v8::internal::MarkCompactCollector::AbortCompaction(), v8::internal::MarkCompactCollector::CollectEvacuationCandidates(), v8::internal::MarkCompactCollector::EvacuatePages(), and v8::internal::MarkCompactCollector::INLINE().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearFlag()

void v8::internal::MemoryChunk::ClearFlag ( int  flag )

inline

Definition at line 407 of file spaces.h.

{ flags_ &= ~(static_cast<uintptr_t>(1) << flag); }

References v8::internal::flag, and flags_.

Referenced by v8::internal::IncrementalMarking::Abort(), v8::internal::MarkCompactCollector::AbortCompaction(), ClearEvacuationCandidate(), v8::internal::Page::ClearWasSwept(), v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), v8::internal::SemiSpace::FlipPages(), initialize_scan_on_scavenge(), v8::internal::PagedSpace::ReleasePage(), ResetProgressBar(), set_scan_on_scavenge(), SetFlagTo(), v8::internal::IncrementalMarking::SetNewSpacePageFlags(), and v8::internal::IncrementalMarking::SetOldSpacePageFlags().

Here is the caller graph for this function:

CommitArea()

bool v8::internal::MemoryChunk::CommitArea

(

size_t

requested

)

Definition at line 476 of file spaces.cc.

                                             {
  size_t guard_size =
      IsFlagSet(IS_EXECUTABLE) ? MemoryAllocator::CodePageGuardSize() : 0;
  size_t header_size = area_start() - address() - guard_size;
  size_t commit_size =
      RoundUp(header_size + requested, base::OS::CommitPageSize());
  size_t committed_size = RoundUp(header_size + (area_end() - area_start()),
                                  base::OS::CommitPageSize());
 
  if (commit_size > committed_size) {
    // Commit size should be less or equal than the reserved size.
    DCHECK(commit_size <= size() - 2 * guard_size);
    // Append the committed area.
    Address start = address() + committed_size + guard_size;
    size_t length = commit_size - committed_size;
    if (reservation_.IsReserved()) {
      Executability executable =
          IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
      if (!heap()->isolate()->memory_allocator()->CommitMemory(start, length,
                                                               executable)) {
        return false;
      }
    } else {
      CodeRange* code_range = heap_->isolate()->code_range();
      DCHECK(code_range != NULL && code_range->valid() &&
             IsFlagSet(IS_EXECUTABLE));
      if (!code_range->CommitRawMemory(start, length)) return false;
    }
 
    if (Heap::ShouldZapGarbage()) {
      heap_->isolate()->memory_allocator()->ZapBlock(start, length);
    }
  } else if (commit_size < committed_size) {
    DCHECK(commit_size > 0);
    // Shrink the committed area.
    size_t length = committed_size - commit_size;
    Address start = address() + committed_size + guard_size - length;
    if (reservation_.IsReserved()) {
      if (!reservation_.Uncommit(start, length)) return false;
    } else {
      CodeRange* code_range = heap_->isolate()->code_range();
      DCHECK(code_range != NULL && code_range->valid() &&
             IsFlagSet(IS_EXECUTABLE));
      if (!code_range->UncommitRawMemory(start, length)) return false;
    }
  }
 
  area_end_ = area_start_ + requested;
  return true;
}

References address(), area_end(), area_end_, area_start(), area_start_, v8::internal::Isolate::code_range(), v8::internal::MemoryAllocator::CodePageGuardSize(), v8::base::OS::CommitPageSize(), v8::internal::CodeRange::CommitRawMemory(), DCHECK, v8::internal::EXECUTABLE, executable(), heap(), heap_, IS_EXECUTABLE, IsFlagSet(), v8::internal::Heap::isolate(), v8::base::VirtualMemory::IsReserved(), v8::internal::Isolate::memory_allocator(), v8::internal::NOT_EXECUTABLE, NULL, reservation_, v8::internal::RoundUp(), v8::internal::Heap::ShouldZapGarbage(), size(), v8::base::VirtualMemory::Uncommit(), v8::internal::CodeRange::UncommitRawMemory(), v8::internal::CodeRange::valid(), and v8::internal::MemoryAllocator::ZapBlock().

Referenced by v8::internal::Deoptimizer::EnsureCodeForDeoptimizationEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

CommittedPhysicalMemory()

size_t v8::internal::MemoryChunk::CommittedPhysicalMemory ( )

inline

Definition at line 637 of file spaces.h.

{ return high_water_mark_; }

References high_water_mark_.

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

Here is the caller graph for this function:

Contains()

bool v8::internal::MemoryChunk::Contains ( Address  addr )

inline

Definition at line 348 of file spaces.h.

                              {
    return addr >= area_start() && addr < area_end();
  }

References area_end(), and area_start().

Referenced by v8::internal::Heap::AllocateCode(), v8::internal::StoreBuffer::ExemptPopularPages(), v8::internal::StoreBuffer::Filter(), v8::internal::LargeObjectSpace::FindPage(), and FromAnyPointerAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

ContainsLimit()

bool v8::internal::MemoryChunk::ContainsLimit ( Address  addr )

inline

Definition at line 355 of file spaces.h.

                                   {
    return addr >= area_start() && addr <= area_end();
  }

References area_end(), and area_start().

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

Here is the call graph for this function:

Here is the caller graph for this function:

ContainsOnlyData()

bool v8::internal::MemoryChunk::ContainsOnlyData ( )

inline

Definition at line 567 of file spaces.h.

{ return IsFlagSet(CONTAINS_ONLY_DATA); }

References CONTAINS_ONLY_DATA, and IsFlagSet().

Here is the call graph for this function:

executable()

Executability v8::internal::MemoryChunk::executable ( )

inline

Definition at line 563 of file spaces.h.

                             {
    return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
  }

References v8::internal::EXECUTABLE, IS_EXECUTABLE, IsFlagSet(), and v8::internal::NOT_EXECUTABLE.

Referenced by CommitArea(), v8::internal::MemoryAllocator::Free(), and Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

FastAddressToMarkbitIndex()

static uint32_t v8::internal::MemoryChunk::FastAddressToMarkbitIndex ( Address  addr )

inlinestatic

Definition at line 590 of file spaces.h.

                                                                 {
    const intptr_t offset = reinterpret_cast<intptr_t>(addr) & kAlignmentMask;
 
    return static_cast<uint32_t>(offset) >> kPointerSizeLog2;
  }

References kAlignmentMask, and v8::internal::kPointerSizeLog2.

Referenced by v8::internal::IsOnInvalidatedCodeObject(), and v8::internal::SetMarkBitsUnderInvalidatedCode().

Here is the caller graph for this function:

FromAddress() [1/2]

static MemoryChunk* v8::internal::MemoryChunk::FromAddress ( Address  a )

inlinestatic

Definition at line 276 of file spaces.h.

                                             {
    return reinterpret_cast<MemoryChunk*>(OffsetFrom(a) & ~kAlignmentMask);
  }

References kAlignmentMask, and OffsetFrom().

Referenced by v8::internal::IncrementalMarking::Abort(), v8::internal::HeapObjectIterator::AdvanceToNextPage(), v8::internal::Heap::AllocateCode(), v8::internal::Heap::AllocateFillerObject(), v8::internal::Heap::AllowedToBeMigrated(), v8::internal::Heap::CanMoveObjectStart(), v8::internal::MarkCompactCollector::ClearMarkbits(), v8::internal::PagedSpace::Contains(), v8::internal::LargeObjectSpace::Contains(), v8::internal::FreeListCategory::ContainsPageFreeListItemsInList(), v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), v8::internal::FreeListCategory::EvictFreeListItemsInList(), v8::internal::FreeList::FindNodeFor(), v8::internal::PagedSpace::FindObject(), v8::internal::FreeList::Free(), v8::internal::Heap::FreeQueuedChunks(), v8::internal::LargeObjectSpace::FreeUnmarkedObjects(), FromAnyPointerAddress(), v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), v8::internal::HeapObject::GetHeap(), IncrementLiveBytesFromGC(), IncrementLiveBytesFromMutator(), Initialize(), v8::internal::MarkCompactCollector::INLINE(), v8::internal::Page::INLINE(), v8::internal::PromotionQueue::IsBelowPromotionQueue(), v8::internal::IsOnInvalidatedCodeObject(), v8::internal::MarkCompactCollector::MigrateObject(), v8::internal::BASE_EMBEDDED< Visitor >::next(), v8::internal::FreeListCategory::PickNodeFromList(), v8::internal::MarkCompactCollector::RecordCodeEntrySlot(), v8::internal::MarkCompactCollector::RecordRelocSlot(), v8::internal::IncrementalMarking::RecordWriteFromCode(), v8::internal::IncrementalMarking::RecordWrites(), v8::internal::SetMarkBitsUnderInvalidatedCode(), v8::internal::PagedSpace::SetTopAndLimit(), v8::internal::Marking::TransferMark(), v8::internal::SkipList::Update(), v8::internal::Heap::UpdateAllocationsHash(), UpdateHighWaterMark(), v8::internal::IncrementalMarking::UpdateMarkingDequeAfterScavenge(), and v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the call graph for this function:

Here is the caller graph for this function:

FromAddress() [2/2]

static const MemoryChunk* v8::internal::MemoryChunk::FromAddress ( const byte *  a )

inlinestatic

Definition at line 279 of file spaces.h.

                                                       {
    return reinterpret_cast<const MemoryChunk*>(OffsetFrom(a) &
                                                ~kAlignmentMask);
  }

References kAlignmentMask, and OffsetFrom().

Here is the call graph for this function:

FromAnyPointerAddress()

MemoryChunk * v8::internal::MemoryChunk::FromAnyPointerAddress ( Heap *  heap, Address  addr  )

inlinestatic

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

                                                                        {
  MemoryChunk* maybe = reinterpret_cast<MemoryChunk*>(
      OffsetFrom(addr) & ~Page::kPageAlignmentMask);
  if (maybe->owner() != NULL) return maybe;
  LargeObjectIterator iterator(heap->lo_space());
  for (HeapObject* o = iterator.Next(); o != NULL; o = iterator.Next()) {
    // Fixed arrays are the only pointer-containing objects in large object
    // space.
    if (o->IsFixedArray()) {
      MemoryChunk* chunk = MemoryChunk::FromAddress(o->address());
      if (chunk->Contains(addr)) {
        return chunk;
      }
    }
  }
  UNREACHABLE();
  return NULL;
}

References Contains(), FromAddress(), heap(), v8::internal::Heap::lo_space(), v8::maybe(), v8::internal::LargeObjectIterator::Next(), NULL, OffsetFrom(), and UNREACHABLE.

Referenced by v8::internal::StoreBuffer::EnterDirectlyIntoStoreBuffer(), v8::internal::StoreBuffer::ExemptPopularPages(), and v8::internal::StoreBuffer::Filter().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFlags()

intptr_t v8::internal::MemoryChunk::GetFlags ( )

inline

Definition at line 429 of file spaces.h.

{ return flags_; }

References flags_.

Referenced by v8::internal::SemiSpace::GrowTo(), and v8::internal::SemiSpace::Swap().

Here is the caller graph for this function:

heap()

Heap* v8::internal::MemoryChunk::heap ( ) const

inline

Definition at line 603 of file spaces.h.

{ return heap_; }

References heap_.

Referenced by CommitArea(), FromAnyPointerAddress(), v8::internal::HeapObject::GetHeap(), v8::internal::HeapObjectIterator::HeapObjectIterator(), Initialize(), v8::internal::NewSpacePage::Initialize(), v8::internal::LargePage::Initialize(), and v8::internal::Page::Initialize().

Here is the caller graph for this function:

IncrementLiveBytes()

void v8::internal::MemoryChunk::IncrementLiveBytes ( int  by )

inline

Definition at line 471 of file spaces.h.

                                  {
    if (FLAG_gc_verbose) {
      printf("UpdateLiveBytes:%p:%x%c=%x->%x\n", static_cast<void*>(this),
             live_byte_count_, ((by < 0) ? '-' : '+'), ((by < 0) ? -by : by),
             live_byte_count_ + by);
    }
    live_byte_count_ += by;
    DCHECK_LE(static_cast<unsigned>(live_byte_count_), size_);
  }

References DCHECK_LE, live_byte_count_, and size_.

Referenced by IncrementLiveBytesFromGC(), and IncrementLiveBytesFromMutator().

Here is the caller graph for this function:

IncrementLiveBytesFromGC()

static void v8::internal::MemoryChunk::IncrementLiveBytesFromGC ( Address  address, int  by  )

inlinestatic

Definition at line 517 of file spaces.h.

                                                                {
    MemoryChunk::FromAddress(address)->IncrementLiveBytes(by);
  }

References address(), FromAddress(), and IncrementLiveBytes().

Referenced by v8::internal::Heap::AdjustLiveBytes(), v8::internal::IncrementalMarking::BlackToGreyAndUnshift(), v8::internal::DiscoverGreyObjectsOnPage(), v8::internal::DiscoverGreyObjectsWithIterator(), v8::internal::IncrementalMarking::Hurry(), v8::internal::IncrementalMarkingMarkingVisitor::INLINE(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::INLINE(), v8::internal::MarkingDeque::INLINE(), v8::internal::MarkBlackOrKeepBlack(), v8::internal::MarkBlackOrKeepGrey(), and v8::internal::MarkObjectGreyDoNotEnqueue().

Here is the call graph for this function:

Here is the caller graph for this function:

IncrementLiveBytesFromMutator()

void v8::internal::MemoryChunk::IncrementLiveBytesFromMutator ( Address  address, int  by  )

static

Definition at line 868 of file spaces.cc.

                                                                       {
  MemoryChunk* chunk = MemoryChunk::FromAddress(address);
  if (!chunk->InNewSpace() && !static_cast<Page*>(chunk)->WasSwept()) {
    static_cast<PagedSpace*>(chunk->owner())->IncrementUnsweptFreeBytes(-by);
  }
  chunk->IncrementLiveBytes(by);
}

References address(), FromAddress(), IncrementLiveBytes(), InNewSpace(), owner(), and v8::internal::Page::WasSwept().

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

Here is the call graph for this function:

Here is the caller graph for this function:

InFromSpace()

bool v8::internal::MemoryChunk::InFromSpace ( )

inline

Definition at line 575 of file spaces.h.

{ return IsFlagSet(IN_FROM_SPACE); }

References IN_FROM_SPACE, and IsFlagSet().

Here is the call graph for this function:

Initialize()

MemoryChunk * v8::internal::MemoryChunk::Initialize ( Heap *  heap, Address  base, size_t  size, Address  area_start, Address  area_end, Executability  executable, Space *  owner  )

staticprotected

Definition at line 430 of file spaces.cc.

                                                                             {
  MemoryChunk* chunk = FromAddress(base);
 
  DCHECK(base == chunk->address());
 
  chunk->heap_ = heap;
  chunk->size_ = size;
  chunk->area_start_ = area_start;
  chunk->area_end_ = area_end;
  chunk->flags_ = 0;
  chunk->set_owner(owner);
  chunk->InitializeReservedMemory();
  chunk->slots_buffer_ = NULL;
  chunk->skip_list_ = NULL;
  chunk->write_barrier_counter_ = kWriteBarrierCounterGranularity;
  chunk->progress_bar_ = 0;
  chunk->high_water_mark_ = static_cast<int>(area_start - base);
  chunk->set_parallel_sweeping(SWEEPING_DONE);
  chunk->available_in_small_free_list_ = 0;
  chunk->available_in_medium_free_list_ = 0;
  chunk->available_in_large_free_list_ = 0;
  chunk->available_in_huge_free_list_ = 0;
  chunk->non_available_small_blocks_ = 0;
  chunk->ResetLiveBytes();
  Bitmap::Clear(chunk);
  chunk->initialize_scan_on_scavenge(false);
  chunk->SetFlag(WAS_SWEPT);
 
  DCHECK(OFFSET_OF(MemoryChunk, flags_) == kFlagsOffset);
  DCHECK(OFFSET_OF(MemoryChunk, live_byte_count_) == kLiveBytesOffset);
 
  if (executable == EXECUTABLE) {
    chunk->SetFlag(IS_EXECUTABLE);
  }
 
  if (owner == heap->old_data_space()) {
    chunk->SetFlag(CONTAINS_ONLY_DATA);
  }
 
  return chunk;
}

References address(), area_end(), area_end_, area_start(), area_start_, available_in_huge_free_list_, available_in_large_free_list_, available_in_medium_free_list_, available_in_small_free_list_, v8::internal::Bitmap::Clear(), CONTAINS_ONLY_DATA, DCHECK, v8::internal::EXECUTABLE, executable(), flags_, FromAddress(), heap(), heap_, high_water_mark_, initialize_scan_on_scavenge(), InitializeReservedMemory(), IS_EXECUTABLE, kFlagsOffset, kLiveBytesOffset, kWriteBarrierCounterGranularity, live_byte_count_, non_available_small_blocks_, NULL, OFFSET_OF, v8::internal::Heap::old_data_space(), owner(), progress_bar_, ResetLiveBytes(), set_owner(), set_parallel_sweeping(), SetFlag(), size(), size_, skip_list_, slots_buffer_, SWEEPING_DONE, WAS_SWEPT, and write_barrier_counter_.

Referenced by v8::internal::MemoryAllocator::AllocateChunk(), and v8::internal::NewSpacePage::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_scan_on_scavenge()

void v8::internal::MemoryChunk::initialize_scan_on_scavenge ( bool  scan )

inline

Definition at line 334 of file spaces.h.

                                              {
    if (scan) {
      SetFlag(SCAN_ON_SCAVENGE);
    } else {
      ClearFlag(SCAN_ON_SCAVENGE);
    }
  }

References ClearFlag(), SCAN_ON_SCAVENGE, and SetFlag().

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

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeReservedMemory()

void v8::internal::MemoryChunk::InitializeReservedMemory ( )

inline

Definition at line 326 of file spaces.h.

{ reservation_.Reset(); }

References reservation_, and v8::base::VirtualMemory::Reset().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

InNewSpace()

bool v8::internal::MemoryChunk::InNewSpace ( )

inline

Definition at line 569 of file spaces.h.

                    {
    return (flags_ & ((1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE))) != 0;
  }

References flags_, IN_FROM_SPACE, and IN_TO_SPACE.

Referenced by IncrementLiveBytesFromMutator(), and v8::internal::NewSpacePage::is_anchor().

Here is the caller graph for this function:

InsertAfter()

void v8::internal::MemoryChunk::InsertAfter

(

MemoryChunk *

other

)

Definition at line 528 of file spaces.cc.

                                                {
  MemoryChunk* other_next = other->next_chunk();
 
  set_next_chunk(other_next);
  set_prev_chunk(other);
  other_next->set_prev_chunk(this);
  other->set_next_chunk(this);
}

References next_chunk(), set_next_chunk(), and set_prev_chunk().

Referenced by v8::internal::SemiSpace::Commit(), v8::internal::PagedSpace::Expand(), v8::internal::SemiSpace::GrowTo(), v8::internal::MarkCompactCollector::MoveEvacuationCandidatesToEndOfPagesList(), and v8::internal::PagedSpace::UseEmergencyMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

InToSpace()

bool v8::internal::MemoryChunk::InToSpace ( )

inline

Definition at line 573 of file spaces.h.

{ return IsFlagSet(IN_TO_SPACE); }

References IN_TO_SPACE, and IsFlagSet().

Here is the call graph for this function:

is_valid()

bool v8::internal::MemoryChunk::is_valid ( )

inline

Definition at line 289 of file spaces.h.

{ return address() != NULL; }

References address(), and NULL.

Referenced by v8::internal::IncrementalMarking::ActivateIncrementalWriteBarrier(), v8::internal::PagedSpace::Contains(), v8::internal::IncrementalMarking::DeactivateIncrementalWriteBarrier(), and v8::internal::LargeObjectSpace::FindPage().

Here is the call graph for this function:

Here is the caller graph for this function:

IsEvacuationCandidate()

bool v8::internal::MemoryChunk::IsEvacuationCandidate ( )

inline

Definition at line 607 of file spaces.h.

{ return IsFlagSet(EVACUATION_CANDIDATE); }

References EVACUATION_CANDIDATE, and IsFlagSet().

Referenced by v8::internal::MarkCompactCollector::EvacuateLiveObjectsFromPage(), v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), v8::internal::MarkCompactCollector::EvacuatePages(), v8::internal::FreeList::FindNodeFor(), v8::internal::MemoryAllocator::Free(), v8::internal::MarkCompactCollector::INLINE(), v8::internal::MarkCompactCollector::MoveEvacuationCandidatesToEndOfPagesList(), v8::internal::FreeListCategory::PickNodeFromList(), v8::internal::MarkCompactCollector::RecordCodeEntrySlot(), v8::internal::MarkCompactCollector::RecordRelocSlot(), v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates(), v8::internal::SetMarkBitsUnderInvalidatedCode(), v8::internal::PagedSpace::ShouldBeSweptBySweeperThreads(), v8::internal::Sweep(), and v8::internal::MarkCompactCollector::SweepSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

IsFlagSet()

bool v8::internal::MemoryChunk::IsFlagSet ( int  flag )

inline

Definition at line 417 of file spaces.h.

                           {
    return (flags_ & (static_cast<uintptr_t>(1) << flag)) != 0;
  }

References v8::internal::flag, and flags_.

Referenced by v8::internal::IncrementalMarking::Abort(), CommitArea(), ContainsOnlyData(), v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), v8::internal::MarkCompactCollector::EvacuatePages(), executable(), v8::internal::StoreBuffer::Filter(), v8::internal::SemiSpace::FlipPages(), InFromSpace(), v8::internal::NewSpacePage::Initialize(), InToSpace(), IsEvacuationCandidate(), progress_bar(), v8::internal::IncrementalMarking::RecordWrites(), v8::internal::PagedSpace::ReleasePage(), ResetProgressBar(), scan_on_scavenge(), set_progress_bar(), v8::internal::SetMarkBitsUnderInvalidatedCode(), v8::internal::Heap::ShouldBePromoted(), v8::internal::PagedSpace::ShouldBeSweptBySweeperThreads(), v8::internal::MarkCompactCollector::SweepSpace(), v8::internal::IncrementalMarking::UpdateMarkingDequeAfterScavenge(), v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental(), and v8::internal::Page::WasSwept().

Here is the caller graph for this function:

IsLeftOfProgressBar()

bool v8::internal::MemoryChunk::IsLeftOfProgressBar ( Object **  slot )

inline

Definition at line 510 of file spaces.h.

                                          {
    Address slot_address = reinterpret_cast<Address>(slot);
    DCHECK(slot_address > this->address());
    return (slot_address - (this->address() + kObjectStartOffset)) <
           progress_bar();
  }

References address(), DCHECK, kObjectStartOffset, and progress_bar().

Here is the call graph for this function:

LiveBytes()

int v8::internal::MemoryChunk::LiveBytes ( )

inline

Definition at line 480 of file spaces.h.

                  {
    DCHECK(static_cast<unsigned>(live_byte_count_) <= size_);
    return live_byte_count_;
  }

References DCHECK, live_byte_count_, and size_.

Referenced by v8::internal::MarkCompactCollector::CollectEvacuationCandidates(), v8::internal::PagedSpace::DecreaseUnsweptFreeBytes(), v8::internal::PagedSpace::FreeEmergencyMemory(), v8::internal::FreeListFragmentation(), v8::internal::PagedSpace::IncreaseUnsweptFreeBytes(), v8::internal::PagedSpace::ReleasePage(), and v8::internal::MarkCompactCollector::SweepSpace().

Here is the caller graph for this function:

MarkbitIndexToAddress()

Address v8::internal::MemoryChunk::MarkbitIndexToAddress ( uint32_t  index )

inline

Definition at line 596 of file spaces.h.

                                                       {
    return this->address() + (index << kPointerSizeLog2);
  }

References address(), and v8::internal::kPointerSizeLog2.

Here is the call graph for this function:

markbits()

Bitmap* v8::internal::MemoryChunk::markbits ( )

inline

Definition at line 580 of file spaces.h.

                            {
    return Bitmap::FromAddress(address() + kHeaderSize);
  }

References address(), and kHeaderSize.

Referenced by v8::internal::Bitmap::Clear(), v8::internal::MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage(), v8::internal::IsOnInvalidatedCodeObject(), PrintMarkbits(), and v8::internal::SetMarkBitsUnderInvalidatedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

MarkEvacuationCandidate()

void v8::internal::MemoryChunk::MarkEvacuationCandidate ( )

inline

Definition at line 621 of file spaces.h.

                                 {
    DCHECK(slots_buffer_ == NULL);
    SetFlag(EVACUATION_CANDIDATE);
  }

References DCHECK, EVACUATION_CANDIDATE, NULL, SetFlag(), and slots_buffer_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

next_chunk()

MemoryChunk* v8::internal::MemoryChunk::next_chunk ( ) const

inline

Definition at line 291 of file spaces.h.

                                  {
    return reinterpret_cast<MemoryChunk*>(base::Acquire_Load(&next_chunk_));
  }

References v8::base::Acquire_Load(), and next_chunk_.

Referenced by v8::internal::Heap::FreeQueuedChunks(), InsertAfter(), v8::internal::Page::next_page(), v8::internal::LargePage::next_page(), v8::internal::NewSpacePage::next_page(), and Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

owner()

Space* v8::internal::MemoryChunk::owner ( ) const

inline

Definition at line 307 of file spaces.h.

                       {
    if ((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
        kPageHeaderTag) {
      return reinterpret_cast<Space*>(reinterpret_cast<intptr_t>(owner_) -
                                      kPageHeaderTag);
    } else {
      return NULL;
    }
  }

References v8::internal::kPageHeaderTag, v8::internal::kPageHeaderTagMask, NULL, and owner_.

Referenced by v8::internal::Heap::AllocateCode(), v8::internal::Heap::AllocateFillerObject(), v8::internal::Heap::AllowedToBeMigrated(), v8::internal::PagedSpace::Contains(), v8::internal::LargeObjectSpace::Contains(), v8::internal::MarkCompactCollector::EvacuateLiveObjectsFromPage(), v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), v8::internal::MarkCompactCollector::EvacuatePages(), v8::internal::MemoryAllocator::Free(), v8::internal::Heap::FreeQueuedChunks(), v8::internal::HeapObjectIterator::HeapObjectIterator(), IncrementLiveBytesFromMutator(), Initialize(), v8::internal::Page::Initialize(), v8::internal::Page::InitializeAsAnchor(), v8::internal::MarkCompactCollector::INLINE(), v8::internal::IsOnInvalidatedCodeObject(), v8::internal::StoreBuffer::IteratePointersToNewSpace(), v8::internal::MarkCompactCollector::MoveEvacuationCandidatesToEndOfPagesList(), v8::internal::NewSpacePage::NewSpacePage(), v8::internal::Page::next_page(), v8::internal::Page::prev_page(), v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates(), v8::internal::NewSpacePage::semi_space(), v8::internal::Page::set_next_page(), v8::internal::Page::set_prev_page(), v8::internal::IncrementalMarking::SetOldSpacePageFlags(), v8::internal::Heap::UpdateAllocationsHash(), and v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the caller graph for this function:

parallel_sweeping()

ParallelSweepingState v8::internal::MemoryChunk::parallel_sweeping ( )

inline

Definition at line 445 of file spaces.h.

                                            {
    return static_cast<ParallelSweepingState>(
        base::Acquire_Load(&parallel_sweeping_));
  }

References v8::base::Acquire_Load(), and parallel_sweeping_.

Referenced by v8::internal::MarkCompactCollector::EvacuatePages(), v8::internal::MarkCompactCollector::ParallelSweepSpaceComplete(), SweepingCompleted(), and v8::internal::MarkCompactCollector::SweepSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

prev_chunk()

MemoryChunk* v8::internal::MemoryChunk::prev_chunk ( ) const

inline

Definition at line 295 of file spaces.h.

                                  {
    return reinterpret_cast<MemoryChunk*>(base::Acquire_Load(&prev_chunk_));
  }

References v8::base::Acquire_Load(), and prev_chunk_.

Referenced by v8::internal::Page::prev_page(), v8::internal::NewSpacePage::prev_page(), and Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintMarkbits()

void v8::internal::MemoryChunk::PrintMarkbits ( )

inline

Definition at line 584 of file spaces.h.

{ markbits()->Print(); }

References markbits(), and v8::internal::Bitmap::Print().

Here is the call graph for this function:

progress_bar()

int v8::internal::MemoryChunk::progress_bar ( )

inline

Definition at line 493 of file spaces.h.

                     {
    DCHECK(IsFlagSet(HAS_PROGRESS_BAR));
    return progress_bar_;
  }

References DCHECK, HAS_PROGRESS_BAR, IsFlagSet(), and progress_bar_.

Referenced by IsLeftOfProgressBar(), set_progress_bar(), and v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the call graph for this function:

Here is the caller graph for this function:

reserved_memory()

base::VirtualMemory* v8::internal::MemoryChunk::reserved_memory ( )

inline

Definition at line 324 of file spaces.h.

{ return &reservation_; }

References reservation_.

Referenced by v8::internal::MemoryAllocator::Free().

Here is the caller graph for this function:

ResetLiveBytes()

void v8::internal::MemoryChunk::ResetLiveBytes ( )

inline

Definition at line 464 of file spaces.h.

                        {
    if (FLAG_gc_verbose) {
      PrintF("ResetLiveBytes:%p:%x->0\n", static_cast<void*>(this),
             live_byte_count_);
    }
    live_byte_count_ = 0;
  }

References live_byte_count_, and v8::internal::PrintF().

Referenced by v8::internal::Bitmap::Clear(), v8::internal::MarkCompactCollector::ClearMarkbits(), v8::internal::MarkCompactCollector::EvacuateLiveObjectsFromPage(), v8::internal::SemiSpace::FlipPages(), v8::internal::LargeObjectSpace::FreeUnmarkedObjects(), Initialize(), v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates(), and v8::internal::Sweep().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetProgressBar()

void v8::internal::MemoryChunk::ResetProgressBar ( )

inline

Definition at line 503 of file spaces.h.

                          {
    if (IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR)) {
      set_progress_bar(0);
      ClearFlag(MemoryChunk::HAS_PROGRESS_BAR);
    }
  }

References ClearFlag(), HAS_PROGRESS_BAR, IsFlagSet(), and set_progress_bar().

Referenced by v8::internal::MarkCompactCollector::ClearMarkbits(), and v8::internal::LargeObjectSpace::FreeUnmarkedObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_on_scavenge()

bool v8::internal::MemoryChunk::scan_on_scavenge ( )

inline

Definition at line 333 of file spaces.h.

{ return IsFlagSet(SCAN_ON_SCAVENGE); }

References IsFlagSet(), and SCAN_ON_SCAVENGE.

Referenced by v8::internal::StoreBufferRebuilder::Callback(), v8::internal::StoreBuffer::EnsureSpace(), v8::internal::StoreBuffer::IteratePointersToNewSpace(), v8::internal::StoreBuffer::PrepareForIteration(), set_scan_on_scavenge(), and v8::internal::IncrementalMarking::SetOldSpacePageFlags().

Here is the call graph for this function:

Here is the caller graph for this function:

set_next_chunk()

void v8::internal::MemoryChunk::set_next_chunk ( MemoryChunk *  next )

inline

Definition at line 299 of file spaces.h.

                                         {
    base::Release_Store(&next_chunk_, reinterpret_cast<base::AtomicWord>(next));
  }

References next_chunk_, and v8::base::Release_Store().

Referenced by v8::internal::NewSpacePage::Initialize(), v8::internal::NewSpacePage::InitializeAsAnchor(), InsertAfter(), v8::internal::Heap::QueueMemoryChunkForFree(), v8::internal::LargePage::set_next_page(), v8::internal::NewSpacePage::set_next_page(), v8::internal::Page::set_next_page(), and Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

set_owner()

void v8::internal::MemoryChunk::set_owner ( Space *  space )

inline

Definition at line 317 of file spaces.h.

                               {
    DCHECK((reinterpret_cast<intptr_t>(space) & kPageHeaderTagMask) == 0);
    owner_ = reinterpret_cast<Address>(space) + kPageHeaderTag;
    DCHECK((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
           kPageHeaderTag);
  }

References DCHECK, v8::internal::kPageHeaderTag, v8::internal::kPageHeaderTagMask, owner_, and space().

Referenced by v8::internal::SemiSpace::FlipPages(), v8::internal::Heap::FreeQueuedChunks(), Initialize(), v8::internal::Page::InitializeAsAnchor(), and v8::internal::NewSpacePage::InitializeAsAnchor().

Here is the call graph for this function:

Here is the caller graph for this function:

set_parallel_sweeping()

void v8::internal::MemoryChunk::set_parallel_sweeping ( ParallelSweepingState  state )

inline

Definition at line 450 of file spaces.h.

                                                          {
    base::Release_Store(&parallel_sweeping_, state);
  }

References parallel_sweeping_, and v8::base::Release_Store().

Referenced by Initialize(), v8::internal::MarkCompactCollector::ParallelSweepSpaceComplete(), v8::internal::Sweep(), and v8::internal::MarkCompactCollector::SweepSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

set_prev_chunk()

void v8::internal::MemoryChunk::set_prev_chunk ( MemoryChunk *  prev )

inline

Definition at line 303 of file spaces.h.

                                         {
    base::Release_Store(&prev_chunk_, reinterpret_cast<base::AtomicWord>(prev));
  }

References prev_chunk_, and v8::base::Release_Store().

Referenced by v8::internal::NewSpacePage::Initialize(), v8::internal::NewSpacePage::InitializeAsAnchor(), InsertAfter(), v8::internal::NewSpacePage::set_prev_page(), v8::internal::Page::set_prev_page(), and Unlink().

Here is the call graph for this function:

Here is the caller graph for this function:

set_progress_bar()

void v8::internal::MemoryChunk::set_progress_bar ( int  progress_bar )

inline

Definition at line 498 of file spaces.h.

                                          {
    DCHECK(IsFlagSet(HAS_PROGRESS_BAR));
    progress_bar_ = progress_bar;
  }

References DCHECK, HAS_PROGRESS_BAR, IsFlagSet(), progress_bar(), and progress_bar_.

Referenced by v8::internal::IncrementalMarking::RecordWrites(), ResetProgressBar(), and v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the call graph for this function:

Here is the caller graph for this function:

set_reserved_memory()

void v8::internal::MemoryChunk::set_reserved_memory ( base::VirtualMemory *  reservation )

inline

Definition at line 328 of file spaces.h.

                                                           {
    DCHECK_NOT_NULL(reservation);
    reservation_.TakeControl(reservation);
  }

References DCHECK_NOT_NULL, reservation_, and v8::base::VirtualMemory::TakeControl().

Referenced by v8::internal::MemoryAllocator::AllocateChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

set_scan_on_scavenge()

void v8::internal::MemoryChunk::set_scan_on_scavenge ( bool  scan )

inline

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

                                                {
  if (scan) {
    if (!scan_on_scavenge()) heap_->increment_scan_on_scavenge_pages();
    SetFlag(SCAN_ON_SCAVENGE);
  } else {
    if (scan_on_scavenge()) heap_->decrement_scan_on_scavenge_pages();
    ClearFlag(SCAN_ON_SCAVENGE);
  }
  heap_->incremental_marking()->SetOldSpacePageFlags(this);
}

References ClearFlag(), v8::internal::Heap::decrement_scan_on_scavenge_pages(), heap_, v8::internal::Heap::increment_scan_on_scavenge_pages(), v8::internal::Heap::incremental_marking(), scan_on_scavenge(), SCAN_ON_SCAVENGE, SetFlag(), and v8::internal::IncrementalMarking::SetOldSpacePageFlags().

Referenced by v8::internal::StoreBufferRebuilder::Callback(), v8::internal::StoreBuffer::ExemptPopularPages(), v8::internal::StoreBuffer::IteratePointersToNewSpace(), and v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates().

Here is the call graph for this function:

Here is the caller graph for this function:

set_size()

void v8::internal::MemoryChunk::set_size ( size_t  size )

inline

Definition at line 556 of file spaces.h.

{ size_ = size; }

References size(), and size_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_skip_list()

void v8::internal::MemoryChunk::set_skip_list ( SkipList *  skip_list )

inline

Definition at line 615 of file spaces.h.

{ skip_list_ = skip_list; }

References skip_list(), and skip_list_.

Referenced by v8::internal::SkipList::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

set_store_buffer_counter()

void v8::internal::MemoryChunk::set_store_buffer_counter ( int  counter )

inline

Definition at line 344 of file spaces.h.

                                             {
    store_buffer_counter_ = counter;
  }

References store_buffer_counter_.

Referenced by v8::internal::StoreBuffer::ExemptPopularPages().

Here is the caller graph for this function:

set_write_barrier_counter()

void v8::internal::MemoryChunk::set_write_barrier_counter ( int  counter )

inline

Definition at line 489 of file spaces.h.

                                              {
    write_barrier_counter_ = counter;
  }

References write_barrier_counter_.

Referenced by v8::internal::IncrementalMarking::RecordWriteFromCode().

Here is the caller graph for this function:

SetArea()

void v8::internal::MemoryChunk::SetArea ( Address  area_start, Address  area_end  )

inline

Definition at line 558 of file spaces.h.

                                                     {
    area_start_ = area_start;
    area_end_ = area_end;
  }

References area_end(), area_end_, area_start(), and area_start_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetFlag()

void v8::internal::MemoryChunk::SetFlag ( int  flag )

inline

Definition at line 405 of file spaces.h.

{ flags_ |= static_cast<uintptr_t>(1) << flag; }

References v8::internal::flag, and flags_.

Referenced by v8::internal::MarkCompactCollector::EvacuatePages(), v8::internal::SemiSpace::FlipPages(), v8::internal::Heap::FreeQueuedChunks(), Initialize(), v8::internal::NewSpacePage::Initialize(), initialize_scan_on_scavenge(), v8::internal::MarkCompactCollector::INLINE(), MarkEvacuationCandidate(), set_scan_on_scavenge(), SetFlagTo(), v8::internal::IncrementalMarking::SetNewSpacePageFlags(), v8::internal::IncrementalMarking::SetOldSpacePageFlags(), v8::internal::Page::SetWasSwept(), and v8::internal::IncrementalMarkingMarkingVisitor::VisitFixedArrayIncremental().

Here is the caller graph for this function:

SetFlags()

void v8::internal::MemoryChunk::SetFlags ( intptr_t  flags, intptr_t  mask  )

inline

Definition at line 424 of file spaces.h.

                                               {
    flags_ = (flags_ & ~mask) | (flags & mask);
  }

References v8::internal::anonymous_namespace{flags.cc}::flags, and flags_.

Referenced by v8::internal::SemiSpace::FlipPages(), v8::internal::SemiSpace::GrowTo(), and v8::internal::NewSpacePage::InitializeAsAnchor().

Here is the caller graph for this function:

SetFlagTo()

void v8::internal::MemoryChunk::SetFlagTo ( int  flag, bool  value  )

inline

Definition at line 409 of file spaces.h.

                                       {
    if (value) {
      SetFlag(flag);
    } else {
      ClearFlag(flag);
    }
  }

References ClearFlag(), v8::internal::flag, and SetFlag().

Here is the call graph for this function:

ShouldSkipEvacuationSlotRecording()

bool v8::internal::MemoryChunk::ShouldSkipEvacuationSlotRecording ( )

inline

Definition at line 609 of file spaces.h.

                                           {
    return (flags_ & kSkipEvacuationSlotsRecordingMask) != 0;
  }

References flags_, and kSkipEvacuationSlotsRecordingMask.

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

Here is the caller graph for this function:

size()

size_t v8::internal::MemoryChunk::size ( ) const

inline

Definition at line 554 of file spaces.h.

{ return size_; }

References size_.

Referenced by v8::internal::LargeObjectSpace::AllocateRaw(), CommitArea(), v8::internal::MemoryAllocator::Free(), v8::internal::Heap::FreeQueuedChunks(), v8::internal::LargeObjectSpace::FreeUnmarkedObjects(), Initialize(), set_size(), v8::internal::IncrementalMarking::SetOldSpacePageFlags(), and v8::internal::LargeObjectSpace::TearDown().

Here is the caller graph for this function:

skip_list()

SkipList* v8::internal::MemoryChunk::skip_list ( )

inline

Definition at line 613 of file spaces.h.

{ return skip_list_; }

References skip_list_.

Referenced by v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), v8::internal::MemoryAllocator::Free(), v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(), set_skip_list(), v8::internal::Sweep(), and v8::internal::SkipList::Update().

Here is the caller graph for this function:

slots_buffer()

SlotsBuffer* v8::internal::MemoryChunk::slots_buffer ( )

inline

Definition at line 617 of file spaces.h.

{ return slots_buffer_; }

References slots_buffer_.

Referenced by v8::internal::MarkCompactCollector::EvacuateNewSpaceAndCandidates(), and v8::internal::MemoryAllocator::Free().

Here is the caller graph for this function:

slots_buffer_address()

SlotsBuffer** v8::internal::MemoryChunk::slots_buffer_address ( )

inline

Definition at line 619 of file spaces.h.

{ return &slots_buffer_; }

References slots_buffer_.

Referenced by v8::internal::MarkCompactCollector::AbortCompaction(), v8::internal::MarkCompactCollector::EvacuatePages(), v8::internal::MarkCompactCollector::RecordCodeEntrySlot(), v8::internal::MarkCompactCollector::RecordRelocSlot(), and v8::internal::MarkCompactCollector::ReleaseEvacuationCandidates().

Here is the caller graph for this function:

store_buffer_counter()

int v8::internal::MemoryChunk::store_buffer_counter ( )

inline

Definition at line 343 of file spaces.h.

{ return store_buffer_counter_; }

References store_buffer_counter_.

Referenced by v8::internal::StoreBuffer::ExemptPopularPages().

Here is the caller graph for this function:

SweepingCompleted()

bool v8::internal::MemoryChunk::SweepingCompleted ( )

inline

Definition at line 460 of file spaces.h.

{ return parallel_sweeping() <= SWEEPING_FINALIZE; }

References parallel_sweeping(), and SWEEPING_FINALIZE.

Referenced by v8::internal::HeapObjectIterator::AdvanceToNextPage(), v8::internal::Heap::CanMoveObjectStart(), v8::internal::HeapObjectIterator::HeapObjectIterator(), and v8::internal::StoreBuffer::IteratePointersToNewSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

TryParallelSweeping()

bool v8::internal::MemoryChunk::TryParallelSweeping ( )

inline

Definition at line 454 of file spaces.h.

                             {
    return base::Acquire_CompareAndSwap(&parallel_sweeping_, SWEEPING_PENDING,
                                        SWEEPING_IN_PROGRESS) ==
           SWEEPING_PENDING;
  }

References v8::base::Acquire_CompareAndSwap(), parallel_sweeping_, SWEEPING_IN_PROGRESS, and SWEEPING_PENDING.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Unlink()

void v8::internal::MemoryChunk::Unlink

(

)

Definition at line 538 of file spaces.cc.

                         {
  MemoryChunk* next_element = next_chunk();
  MemoryChunk* prev_element = prev_chunk();
  next_element->set_prev_chunk(prev_element);
  prev_element->set_next_chunk(next_element);
  set_prev_chunk(NULL);
  set_next_chunk(NULL);
}

References next_chunk(), NULL, prev_chunk(), set_next_chunk(), and set_prev_chunk().

Referenced by v8::internal::MarkCompactCollector::MoveEvacuationCandidatesToEndOfPagesList(), and v8::internal::PagedSpace::ReleasePage().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateHighWaterMark()

void v8::internal::MemoryChunk::UpdateHighWaterMark ( Address  mark )

inlinestatic

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

                                                  {
  if (mark == NULL) return;
  // Need to subtract one from the mark because when a chunk is full the
  // top points to the next address after the chunk, which effectively belongs
  // to another chunk. See the comment to Page::FromAllocationTop.
  MemoryChunk* chunk = MemoryChunk::FromAddress(mark - 1);
  int new_mark = static_cast<int>(mark - chunk->address());
  if (new_mark > chunk->high_water_mark_) {
    chunk->high_water_mark_ = new_mark;
  }
}

References address(), FromAddress(), high_water_mark_, and NULL.

Referenced by v8::internal::PagedSpace::CommittedPhysicalMemory(), v8::internal::NewSpace::CommittedPhysicalMemory(), v8::internal::PagedSpace::SetTopAndLimit(), and v8::internal::NewSpace::UpdateAllocationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

write_barrier_counter()

int v8::internal::MemoryChunk::write_barrier_counter ( )

inline

Definition at line 485 of file spaces.h.

                              {
    return static_cast<int>(write_barrier_counter_);
  }

References write_barrier_counter_.

Referenced by v8::internal::IncrementalMarking::RecordWriteFromCode().

Here is the caller graph for this function:

Friends And Related Function Documentation

MemoryAllocator

friend class MemoryAllocator

friend

Definition at line 690 of file spaces.h.

Member Data Documentation

area_end_

Address v8::internal::MemoryChunk::area_end_

protected

Definition at line 647 of file spaces.h.

Referenced by area_end(), CommitArea(), Initialize(), and SetArea().

area_start_

Address v8::internal::MemoryChunk::area_start_

protected

Definition at line 646 of file spaces.h.

Referenced by area_start(), CommitArea(), Initialize(), and SetArea().

available_in_huge_free_list_

intptr_t v8::internal::MemoryChunk::available_in_huge_free_list_

protected

Definition at line 677 of file spaces.h.

Referenced by Initialize(), and v8::internal::Page::ResetFreeListStatistics().

available_in_large_free_list_

intptr_t v8::internal::MemoryChunk::available_in_large_free_list_

protected

Definition at line 676 of file spaces.h.

Referenced by Initialize(), and v8::internal::Page::ResetFreeListStatistics().

available_in_medium_free_list_

intptr_t v8::internal::MemoryChunk::available_in_medium_free_list_

protected

Definition at line 675 of file spaces.h.

Referenced by Initialize(), and v8::internal::Page::ResetFreeListStatistics().

available_in_small_free_list_

intptr_t v8::internal::MemoryChunk::available_in_small_free_list_

protected

Definition at line 674 of file spaces.h.

Referenced by Initialize(), and v8::internal::Page::ResetFreeListStatistics().

flags_

intptr_t v8::internal::MemoryChunk::flags_

protected

Definition at line 643 of file spaces.h.

Referenced by ClearFlag(), GetFlags(), Initialize(), InNewSpace(), IsFlagSet(), SetFlag(), SetFlags(), and ShouldSkipEvacuationSlotRecording().

heap_

Heap* v8::internal::MemoryChunk::heap_

protected

Definition at line 655 of file spaces.h.

Referenced by CommitArea(), heap(), Initialize(), and set_scan_on_scavenge().

high_water_mark_

int v8::internal::MemoryChunk::high_water_mark_

protected

Definition at line 669 of file spaces.h.

Referenced by CommittedPhysicalMemory(), Initialize(), and UpdateHighWaterMark().

kAlignment

const intptr_t v8::internal::MemoryChunk::kAlignment

static

Initial value:

=
      (static_cast<uintptr_t>(1) << kPageSizeBits)

Definition at line 523 of file spaces.h.

Referenced by v8::internal::MemoryAllocator::AllocateChunk(), v8::internal::LargeObjectSpace::AllocateRaw(), v8::internal::CodeRange::AllocateRawMemory(), v8::internal::LargeObjectSpace::FindPage(), v8::internal::CodeRange::FreeBlock::FreeBlock(), v8::internal::CodeRange::FreeRawMemory(), v8::internal::LargeObjectSpace::FreeUnmarkedObjects(), and v8::internal::CodeRange::SetUp().

kAlignmentMask

const intptr_t v8::internal::MemoryChunk::kAlignmentMask = kAlignment - 1

static

Definition at line 526 of file spaces.h.

Referenced by FastAddressToMarkbitIndex(), FromAddress(), and v8::internal::ObjectAddressForHashing().

kBodyOffset

const int v8::internal::MemoryChunk::kBodyOffset

static

Initial value:

=
      CODE_POINTER_ALIGN(kHeaderSize + Bitmap::kSize)

Definition at line 543 of file spaces.h.

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

kEvacuationCandidateMask

const int v8::internal::MemoryChunk::kEvacuationCandidateMask = 1 << EVACUATION_CANDIDATE

static

Definition at line 398 of file spaces.h.

kFlagsOffset

const int v8::internal::MemoryChunk::kFlagsOffset = kPointerSize

static

Definition at line 605 of file spaces.h.

Referenced by Initialize().

kHeaderSize

const size_t v8::internal::MemoryChunk::kHeaderSize

static

Initial value:

=
      kWriteBarrierCounterOffset + kPointerSize + kIntSize + kIntSize +
      kPointerSize + 5 * kPointerSize + kPointerSize + kPointerSize

Definition at line 539 of file spaces.h.

Referenced by markbits().

kLiveBytesOffset

const intptr_t v8::internal::MemoryChunk::kLiveBytesOffset

static

Initial value:

=
      kSizeOffset + kPointerSize + kPointerSize + kPointerSize + kPointerSize +
      kPointerSize + kPointerSize + kPointerSize + kPointerSize + kIntSize

Definition at line 530 of file spaces.h.

Referenced by Initialize().

kObjectStartAlignment

const int v8::internal::MemoryChunk::kObjectStartAlignment = 32 * kPointerSize

static

Definition at line 549 of file spaces.h.

kObjectStartOffset

const int v8::internal::MemoryChunk::kObjectStartOffset

static

Initial value:

=
      kBodyOffset - 1 +
      (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment)

Definition at line 550 of file spaces.h.

Referenced by v8::internal::MemoryAllocator::AllocateChunk(), v8::internal::MemoryAllocator::CodePageGuardStartOffset(), v8::internal::NewSpacePage::Initialize(), v8::internal::NewSpacePage::IsAtStart(), IsLeftOfProgressBar(), v8::internal::LargeObjectSpace::ObjectSizeFor(), v8::internal::PagedSpace::PagedSpace(), and v8::internal::Serializer::SpaceAreaSize().

kPointersFromHereAreInterestingMask

const int v8::internal::MemoryChunk::kPointersFromHereAreInterestingMask

static

Initial value:

=
      1 << POINTERS_FROM_HERE_ARE_INTERESTING

Definition at line 395 of file spaces.h.

kPointersToHereAreInterestingMask

const int v8::internal::MemoryChunk::kPointersToHereAreInterestingMask

static

Initial value:

=
      1 << POINTERS_TO_HERE_ARE_INTERESTING

Definition at line 392 of file spaces.h.

kSizeOffset

const intptr_t v8::internal::MemoryChunk::kSizeOffset = 0

static

Definition at line 528 of file spaces.h.

kSkipEvacuationSlotsRecordingMask

const int v8::internal::MemoryChunk::kSkipEvacuationSlotsRecordingMask

static

Initial value:

=
      (1 << EVACUATION_CANDIDATE) | (1 << RESCAN_ON_EVACUATION) |
      (1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE)

Definition at line 400 of file spaces.h.

Referenced by ShouldSkipEvacuationSlotRecording().

kSlotsBufferOffset

const size_t v8::internal::MemoryChunk::kSlotsBufferOffset = kLiveBytesOffset + kIntSize

static

Definition at line 534 of file spaces.h.

kWriteBarrierCounterGranularity

const int v8::internal::MemoryChunk::kWriteBarrierCounterGranularity = 500

static

Definition at line 362 of file spaces.h.

Referenced by Initialize(), and v8::internal::IncrementalMarking::RecordWriteFromCode().

kWriteBarrierCounterOffset

const size_t v8::internal::MemoryChunk::kWriteBarrierCounterOffset

static

Initial value:

=
      kSlotsBufferOffset + kPointerSize + kPointerSize

Definition at line 536 of file spaces.h.

live_byte_count_

int v8::internal::MemoryChunk::live_byte_count_

protected

Definition at line 660 of file spaces.h.

Referenced by IncrementLiveBytes(), Initialize(), LiveBytes(), and ResetLiveBytes().

next_chunk_

base::AtomicWord v8::internal::MemoryChunk::next_chunk_

private

Definition at line 686 of file spaces.h.

Referenced by next_chunk(), and set_next_chunk().

non_available_small_blocks_

intptr_t v8::internal::MemoryChunk::non_available_small_blocks_

protected

Definition at line 678 of file spaces.h.

Referenced by Initialize(), and v8::internal::Page::ResetFreeListStatistics().

owner_

Address v8::internal::MemoryChunk::owner_

protected

Definition at line 654 of file spaces.h.

Referenced by owner(), and set_owner().

parallel_sweeping_

base::AtomicWord v8::internal::MemoryChunk::parallel_sweeping_

protected

Definition at line 671 of file spaces.h.

Referenced by parallel_sweeping(), set_parallel_sweeping(), and TryParallelSweeping().

prev_chunk_

base::AtomicWord v8::internal::MemoryChunk::prev_chunk_

private

Definition at line 688 of file spaces.h.

Referenced by prev_chunk(), and set_prev_chunk().

progress_bar_

int v8::internal::MemoryChunk::progress_bar_

protected

Definition at line 666 of file spaces.h.

Referenced by Initialize(), progress_bar(), and set_progress_bar().

reservation_

base::VirtualMemory v8::internal::MemoryChunk::reservation_

protected

Definition at line 650 of file spaces.h.

Referenced by CommitArea(), InitializeReservedMemory(), reserved_memory(), and set_reserved_memory().

size_

size_t v8::internal::MemoryChunk::size_

protected

Definition at line 642 of file spaces.h.

Referenced by IncrementLiveBytes(), Initialize(), LiveBytes(), set_size(), and size().

skip_list_

SkipList* v8::internal::MemoryChunk::skip_list_

protected

Definition at line 662 of file spaces.h.

Referenced by Initialize(), set_skip_list(), and skip_list().

slots_buffer_

SlotsBuffer* v8::internal::MemoryChunk::slots_buffer_

protected

Definition at line 661 of file spaces.h.

Referenced by ClearEvacuationCandidate(), Initialize(), MarkEvacuationCandidate(), slots_buffer(), and slots_buffer_address().

store_buffer_counter_

int v8::internal::MemoryChunk::store_buffer_counter_

protected

Definition at line 658 of file spaces.h.

Referenced by set_store_buffer_counter(), and store_buffer_counter().

write_barrier_counter_

intptr_t v8::internal::MemoryChunk::write_barrier_counter_

protected

Definition at line 663 of file spaces.h.

Referenced by Initialize(), set_write_barrier_counter(), and write_barrier_counter().

---

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