v8::internal::LargeObjectSpace Class Reference

#include <spaces.h>

Inheritance diagram for v8::internal::LargeObjectSpace:

Collaboration diagram for v8::internal::LargeObjectSpace:

Public Member Functions
	LargeObjectSpace (Heap *heap, intptr_t max_capacity, AllocationSpace id)
virtual	~LargeObjectSpace ()
bool	SetUp ()
void	TearDown ()
MUST_USE_RESULT AllocationResult	AllocateRaw (int object_size, Executability executable)
bool	CanAllocateSize (int size)
intptr_t	Available ()
virtual intptr_t	Size ()
virtual intptr_t	SizeOfObjects ()
intptr_t	MaximumCommittedMemory ()
intptr_t	CommittedMemory ()
size_t	CommittedPhysicalMemory ()
int	PageCount ()
Object *	FindObject (Address a)
LargePage *	FindPage (Address a)
void	FreeUnmarkedObjects ()
bool	Contains (HeapObject *obj)
bool	IsEmpty ()
LargePage *	first_page ()
bool	SlowContains (Address addr)
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 intptr_t	ObjectSizeFor (intptr_t chunk_size)
Static Public Member Functions inherited from v8::internal::Malloced
static void	FatalProcessOutOfMemory ()
static void *	New (size_t size)
static void	Delete (void *p)

Private Attributes
intptr_t	max_capacity_
intptr_t	maximum_committed_
LargePage *	first_page_
intptr_t	size_
int	page_count_
intptr_t	objects_size_
HashMap	chunk_map_

Friends
class	LargeObjectIterator

Detailed Description

Definition at line 2714 of file spaces.h.

Constructor & Destructor Documentation

LargeObjectSpace()

v8::internal::LargeObjectSpace::LargeObjectSpace	(	Heap *	heap,
		intptr_t	max_capacity,
		AllocationSpace	id
	)

Definition at line 2797 of file spaces.cc.

    : Space(heap, id, NOT_EXECUTABLE),  // Managed on a per-allocation basis
      max_capacity_(max_capacity),
      first_page_(NULL),
      size_(0),
      page_count_(0),
      objects_size_(0),
      chunk_map_(ComparePointers, 1024) {}

~LargeObjectSpace()

virtual v8::internal::LargeObjectSpace::~LargeObjectSpace ( )

inlinevirtual

Definition at line 2717 of file spaces.h.

{}

Member Function Documentation

AllocateRaw()

AllocationResult v8::internal::LargeObjectSpace::AllocateRaw	(	int	object_size,
		Executability	executable
	)

Definition at line 2834 of file spaces.cc.

                                                                         {
  // Check if we want to force a GC before growing the old space further.
  // If so, fail the allocation.
  if (!heap()->always_allocate() &&
      heap()->OldGenerationAllocationLimitReached()) {
    return AllocationResult::Retry(identity());
  }
 
  if (!CanAllocateSize(object_size)) return AllocationResult::Retry(identity());
 
  LargePage* page = heap()->isolate()->memory_allocator()->AllocateLargePage(
      object_size, this, executable);
  if (page == NULL) return AllocationResult::Retry(identity());
  DCHECK(page->area_size() >= object_size);
 
  size_ += static_cast<int>(page->size());
  objects_size_ += object_size;
  page_count_++;
  page->set_next_page(first_page_);
  first_page_ = page;
 
  if (size_ > maximum_committed_) {
    maximum_committed_ = size_;
  }
 
  // Register all MemoryChunk::kAlignment-aligned chunks covered by
  // this large page in the chunk map.
  uintptr_t base = reinterpret_cast<uintptr_t>(page) / MemoryChunk::kAlignment;
  uintptr_t limit = base + (page->size() - 1) / MemoryChunk::kAlignment;
  for (uintptr_t key = base; key <= limit; key++) {
    HashMap::Entry* entry = chunk_map_.Lookup(reinterpret_cast<void*>(key),
                                              static_cast<uint32_t>(key), true);
    DCHECK(entry != NULL);
    entry->value = page;
  }
 
  HeapObject* object = page->GetObject();
 
  MSAN_ALLOCATED_UNINITIALIZED_MEMORY(object->address(), object_size);
 
  if (Heap::ShouldZapGarbage()) {
    // Make the object consistent so the heap can be verified in OldSpaceStep.
    // We only need to do this in debug builds or if verify_heap is on.
    reinterpret_cast<Object**>(object->address())[0] =
        heap()->fixed_array_map();
    reinterpret_cast<Object**>(object->address())[1] = Smi::FromInt(0);
  }
 
  heap()->incremental_marking()->OldSpaceStep(object_size);
  return object;
}

References v8::internal::HeapObject::address(), v8::internal::MemoryAllocator::AllocateLargePage(), v8::internal::MemoryChunk::area_size(), CanAllocateSize(), chunk_map_, DCHECK, v8::internal::Space::executable(), first_page_, v8::internal::Smi::FromInt(), v8::internal::LargePage::GetObject(), v8::internal::Space::heap(), v8::internal::Space::identity(), v8::internal::Heap::incremental_marking(), v8::internal::Heap::isolate(), v8::internal::MemoryChunk::kAlignment, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), maximum_committed_, v8::internal::Isolate::memory_allocator(), MSAN_ALLOCATED_UNINITIALIZED_MEMORY, NULL, objects_size_, v8::internal::IncrementalMarking::OldSpaceStep(), page_count_, v8::internal::AllocationResult::Retry(), v8::internal::LargePage::set_next_page(), v8::internal::Heap::ShouldZapGarbage(), v8::internal::MemoryChunk::size(), and size_.

Referenced by v8::internal::Deserializer::Allocate(), v8::internal::Heap::AllocateCode(), and v8::internal::Heap::AllocateRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

Available()

intptr_t v8::internal::LargeObjectSpace::Available ( )

inline

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

                                     {
  return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
}

References v8::internal::Space::heap(), and ObjectSizeFor().

Referenced by 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:

CanAllocateSize()

bool v8::internal::LargeObjectSpace::CanAllocateSize ( int  size )

inline

Definition at line 2735 of file spaces.h.

{ return Size() + size <= max_capacity_; }

References max_capacity_, size, and Size().

Referenced by AllocateRaw(), and v8::internal::Heap::ReserveSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

CommittedMemory()

intptr_t v8::internal::LargeObjectSpace::CommittedMemory ( )

inline

Definition at line 2746 of file spaces.h.

{ return Size(); }

References Size().

Referenced by 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::LargeObjectSpace::CommittedPhysicalMemory

(

)

Definition at line 2888 of file spaces.cc.

                                                 {
  if (!base::VirtualMemory::HasLazyCommits()) return CommittedMemory();
  size_t size = 0;
  LargePage* current = first_page_;
  while (current != NULL) {
    size += current->CommittedPhysicalMemory();
    current = current->next_page();
  }
  return size;
}

References CommittedMemory(), v8::internal::MemoryChunk::CommittedPhysicalMemory(), first_page_, v8::base::VirtualMemory::HasLazyCommits(), v8::internal::LargePage::next_page(), NULL, and size.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Contains()

bool v8::internal::LargeObjectSpace::Contains

(

HeapObject *

obj

)

Definition at line 2980 of file spaces.cc.

                                                  {
  Address address = object->address();
  MemoryChunk* chunk = MemoryChunk::FromAddress(address);
 
  bool owned = (chunk->owner() == this);
 
  SLOW_DCHECK(!owned || FindObject(address)->IsHeapObject());
 
  return owned;
}

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

Referenced by v8::internal::BUILTIN().

Here is the call graph for this function:

Here is the caller graph for this function:

FindObject()

Object * v8::internal::LargeObjectSpace::FindObject

(

Address

a

)

Definition at line 2901 of file spaces.cc.

                                              {
  LargePage* page = FindPage(a);
  if (page != NULL) {
    return page->GetObject();
  }
  return Smi::FromInt(0);  // Signaling not found.
}

References FindPage(), v8::internal::Smi::FromInt(), v8::internal::LargePage::GetObject(), and NULL.

Referenced by Contains(), and SlowContains().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPage()

LargePage * v8::internal::LargeObjectSpace::FindPage

(

Address

a

)

Definition at line 2910 of file spaces.cc.

                                               {
  uintptr_t key = reinterpret_cast<uintptr_t>(a) / MemoryChunk::kAlignment;
  HashMap::Entry* e = chunk_map_.Lookup(reinterpret_cast<void*>(key),
                                        static_cast<uint32_t>(key), false);
  if (e != NULL) {
    DCHECK(e->value != NULL);
    LargePage* page = reinterpret_cast<LargePage*>(e->value);
    DCHECK(page->is_valid());
    if (page->Contains(a)) {
      return page;
    }
  }
  return NULL;
}

References chunk_map_, v8::internal::MemoryChunk::Contains(), DCHECK, v8::internal::MemoryChunk::is_valid(), v8::internal::MemoryChunk::kAlignment, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), and NULL.

Referenced by FindObject(), and v8::internal::InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer().

Here is the call graph for this function:

Here is the caller graph for this function:

first_page()

LargePage* v8::internal::LargeObjectSpace::first_page ( )

inline

Definition at line 2770 of file spaces.h.

{ return first_page_; }

References first_page_.

Referenced by v8::internal::IncrementalMarking::ActivateIncrementalWriteBarrier(), and v8::internal::IncrementalMarking::DeactivateIncrementalWriteBarrier().

Here is the caller graph for this function:

FreeUnmarkedObjects()

void v8::internal::LargeObjectSpace::FreeUnmarkedObjects

(

)

Definition at line 2926 of file spaces.cc.

                                           {
  LargePage* previous = NULL;
  LargePage* current = first_page_;
  while (current != NULL) {
    HeapObject* object = current->GetObject();
    // Can this large page contain pointers to non-trivial objects.  No other
    // pointer object is this big.
    bool is_pointer_object = object->IsFixedArray();
    MarkBit mark_bit = Marking::MarkBitFrom(object);
    if (mark_bit.Get()) {
      mark_bit.Clear();
      Page::FromAddress(object->address())->ResetProgressBar();
      Page::FromAddress(object->address())->ResetLiveBytes();
      previous = current;
      current = current->next_page();
    } else {
      LargePage* page = current;
      // Cut the chunk out from the chunk list.
      current = current->next_page();
      if (previous == NULL) {
        first_page_ = current;
      } else {
        previous->set_next_page(current);
      }
 
      // Free the chunk.
      heap()->mark_compact_collector()->ReportDeleteIfNeeded(object,
                                                             heap()->isolate());
      size_ -= static_cast<int>(page->size());
      objects_size_ -= object->Size();
      page_count_--;
 
      // Remove entries belonging to this page.
      // Use variable alignment to help pass length check (<= 80 characters)
      // of single line in tools/presubmit.py.
      const intptr_t alignment = MemoryChunk::kAlignment;
      uintptr_t base = reinterpret_cast<uintptr_t>(page) / alignment;
      uintptr_t limit = base + (page->size() - 1) / alignment;
      for (uintptr_t key = base; key <= limit; key++) {
        chunk_map_.Remove(reinterpret_cast<void*>(key),
                          static_cast<uint32_t>(key));
      }
 
      if (is_pointer_object) {
        heap()->QueueMemoryChunkForFree(page);
      } else {
        heap()->isolate()->memory_allocator()->Free(page);
      }
    }
  }
  heap()->FreeQueuedChunks();
}

References v8::internal::HeapObject::address(), chunk_map_, v8::internal::MarkBit::Clear(), first_page_, v8::internal::MemoryAllocator::Free(), v8::internal::Heap::FreeQueuedChunks(), v8::internal::MemoryChunk::FromAddress(), v8::internal::MarkBit::Get(), v8::internal::LargePage::GetObject(), v8::internal::Space::heap(), v8::internal::Heap::isolate(), v8::internal::MemoryChunk::kAlignment, v8::internal::Heap::mark_compact_collector(), v8::internal::Isolate::memory_allocator(), v8::internal::LargePage::next_page(), NULL, objects_size_, page_count_, v8::internal::Heap::QueueMemoryChunkForFree(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Remove(), v8::internal::MarkCompactCollector::ReportDeleteIfNeeded(), v8::internal::MemoryChunk::ResetLiveBytes(), v8::internal::MemoryChunk::ResetProgressBar(), v8::internal::LargePage::set_next_page(), v8::internal::MemoryChunk::size(), and size_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

IsEmpty()

bool v8::internal::LargeObjectSpace::IsEmpty ( )

inline

Definition at line 2768 of file spaces.h.

{ return first_page_ == NULL; }

References first_page_, and NULL.

MaximumCommittedMemory()

intptr_t v8::internal::LargeObjectSpace::MaximumCommittedMemory ( )

inline

Definition at line 2744 of file spaces.h.

{ return maximum_committed_; }

References maximum_committed_.

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

Here is the caller graph for this function:

ObjectSizeFor()

static intptr_t v8::internal::LargeObjectSpace::ObjectSizeFor ( intptr_t  chunk_size )

inlinestatic

Definition at line 2725 of file spaces.h.

                                                     {
    if (chunk_size <= (Page::kPageSize + Page::kObjectStartOffset)) return 0;
    return chunk_size - Page::kPageSize - Page::kObjectStartOffset;
  }

References v8::internal::MemoryChunk::kObjectStartOffset, and v8::internal::Page::kPageSize.

Referenced by Available().

Here is the caller graph for this function:

PageCount()

int v8::internal::LargeObjectSpace::PageCount ( )

inline

Definition at line 2751 of file spaces.h.

{ return page_count_; }

References page_count_.

SetUp()

bool v8::internal::LargeObjectSpace::SetUp

(

)

Definition at line 2808 of file spaces.cc.

                             {
  first_page_ = NULL;
  size_ = 0;
  maximum_committed_ = 0;
  page_count_ = 0;
  objects_size_ = 0;
  chunk_map_.Clear();
  return true;
}

References chunk_map_, v8::internal::TemplateHashMapImpl< AllocationPolicy >::Clear(), first_page_, maximum_committed_, NULL, objects_size_, page_count_, and size_.

Referenced by v8::internal::Heap::SetUp(), and TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

Size()

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

inlinevirtual

Implements v8::internal::Space.

Definition at line 2740 of file spaces.h.

{ return size_; }

References size_.

Referenced by CanAllocateSize(), v8::internal::Heap::CommittedMemory(), CommittedMemory(), v8::internal::StatisticsExtension::GetCounters(), and v8::internal::Heap::RecordStats().

Here is the caller graph for this function:

SizeOfObjects()

virtual intptr_t v8::internal::LargeObjectSpace::SizeOfObjects ( )

inlinevirtual

Reimplemented from v8::internal::Space.

Definition at line 2742 of file spaces.h.

{ return objects_size_; }

References objects_size_.

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

Here is the caller graph for this function:

SlowContains()

bool v8::internal::LargeObjectSpace::SlowContains ( Address  addr )

inline

Definition at line 2783 of file spaces.h.

{ return FindObject(addr)->IsHeapObject(); }

References FindObject().

Referenced by v8::internal::Heap::Contains(), and v8::internal::Heap::InSpace().

Here is the call graph for this function:

Here is the caller graph for this function:

TearDown()

void v8::internal::LargeObjectSpace::TearDown

(

)

Definition at line 2819 of file spaces.cc.

                                {
  while (first_page_ != NULL) {
    LargePage* page = first_page_;
    first_page_ = first_page_->next_page();
    LOG(heap()->isolate(), DeleteEvent("LargeObjectChunk", page->address()));
 
    ObjectSpace space = static_cast<ObjectSpace>(1 << identity());
    heap()->isolate()->memory_allocator()->PerformAllocationCallback(
        space, kAllocationActionFree, page->size());
    heap()->isolate()->memory_allocator()->Free(page);
  }
  SetUp();
}

References v8::internal::MemoryChunk::address(), first_page_, v8::internal::MemoryAllocator::Free(), v8::internal::Space::heap(), v8::internal::Space::identity(), v8::internal::Heap::isolate(), v8::kAllocationActionFree, LOG, v8::internal::Isolate::memory_allocator(), v8::internal::LargePage::next_page(), NULL, v8::internal::MemoryAllocator::PerformAllocationCallback(), SetUp(), v8::internal::MemoryChunk::size(), and space().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

LargeObjectIterator

friend class LargeObjectIterator

friend

Definition at line 2796 of file spaces.h.

Member Data Documentation

chunk_map_

HashMap v8::internal::LargeObjectSpace::chunk_map_

private

Definition at line 2794 of file spaces.h.

Referenced by AllocateRaw(), FindPage(), FreeUnmarkedObjects(), and SetUp().

first_page_

LargePage* v8::internal::LargeObjectSpace::first_page_

private

Definition at line 2789 of file spaces.h.

Referenced by AllocateRaw(), CommittedPhysicalMemory(), first_page(), FreeUnmarkedObjects(), IsEmpty(), SetUp(), and TearDown().

max_capacity_

intptr_t v8::internal::LargeObjectSpace::max_capacity_

private

Definition at line 2786 of file spaces.h.

Referenced by CanAllocateSize().

maximum_committed_

intptr_t v8::internal::LargeObjectSpace::maximum_committed_

private

Definition at line 2787 of file spaces.h.

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

objects_size_

intptr_t v8::internal::LargeObjectSpace::objects_size_

private

Definition at line 2792 of file spaces.h.

Referenced by AllocateRaw(), FreeUnmarkedObjects(), SetUp(), and SizeOfObjects().

page_count_

int v8::internal::LargeObjectSpace::page_count_

private

Definition at line 2791 of file spaces.h.

Referenced by AllocateRaw(), FreeUnmarkedObjects(), PageCount(), and SetUp().

size_

intptr_t v8::internal::LargeObjectSpace::size_

private

Definition at line 2790 of file spaces.h.

Referenced by AllocateRaw(), FreeUnmarkedObjects(), SetUp(), and Size().

---

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