v8::internal::MemoryAllocator Class Reference

#include <spaces.h>

Collaboration diagram for v8::internal::MemoryAllocator:

Classes
struct	MemoryAllocationCallbackRegistration

Public Member Functions
	MemoryAllocator (Isolate *isolate)
bool	SetUp (intptr_t max_capacity, intptr_t capacity_executable)
void	TearDown ()
Page *	AllocatePage (intptr_t size, PagedSpace *owner, Executability executable)
LargePage *	AllocateLargePage (intptr_t object_size, Space *owner, Executability executable)
void	Free (MemoryChunk *chunk)
intptr_t	Available ()
intptr_t	Size ()
intptr_t	AvailableExecutable ()
intptr_t	SizeExecutable ()
intptr_t	MaxAvailable ()
bool	IsOutsideAllocatedSpace (const void *address) const
MemoryChunk *	AllocateChunk (intptr_t reserve_area_size, intptr_t commit_area_size, Executability executable, Space *space)
Address	ReserveAlignedMemory (size_t requested, size_t alignment, base::VirtualMemory *controller)
Address	AllocateAlignedMemory (size_t reserve_size, size_t commit_size, size_t alignment, Executability executable, base::VirtualMemory *controller)
bool	CommitMemory (Address addr, size_t size, Executability executable)
void	FreeMemory (base::VirtualMemory *reservation, Executability executable)
void	FreeMemory (Address addr, size_t size, Executability executable)
bool	CommitBlock (Address start, size_t size, Executability executable)
bool	UncommitBlock (Address start, size_t size)
void	ZapBlock (Address start, size_t size)
void	PerformAllocationCallback (ObjectSpace space, AllocationAction action, size_t size)
void	AddMemoryAllocationCallback (MemoryAllocationCallback callback, ObjectSpace space, AllocationAction action)
void	RemoveMemoryAllocationCallback (MemoryAllocationCallback callback)
bool	MemoryAllocationCallbackRegistered (MemoryAllocationCallback callback)
MUST_USE_RESULT bool	CommitExecutableMemory (base::VirtualMemory *vm, Address start, size_t commit_size, size_t reserved_size)

Static Public Member Functions
static int	CodePageGuardStartOffset ()
static int	CodePageGuardSize ()
static int	CodePageAreaStartOffset ()
static int	CodePageAreaEndOffset ()
static int	CodePageAreaSize ()

Private Member Functions
Page *	InitializePagesInChunk (int chunk_id, int pages_in_chunk, PagedSpace *owner)
void	UpdateAllocatedSpaceLimits (void *low, void *high)
	DISALLOW_IMPLICIT_CONSTRUCTORS (MemoryAllocator)

Private Attributes
Isolate *	isolate_
size_t	capacity_
size_t	capacity_executable_
size_t	size_
size_t	size_executable_
void *	lowest_ever_allocated_
void *	highest_ever_allocated_
List< MemoryAllocationCallbackRegistration >	memory_allocation_callbacks_

Detailed Description

Definition at line 1001 of file spaces.h.

Constructor & Destructor Documentation

MemoryAllocator()

v8::internal::MemoryAllocator::MemoryAllocator ( Isolate *  isolate )

explicit

Definition at line 252 of file spaces.cc.

    : isolate_(isolate),
      capacity_(0),
      capacity_executable_(0),
      size_(0),
      size_executable_(0),
      lowest_ever_allocated_(reinterpret_cast<void*>(-1)),
      highest_ever_allocated_(reinterpret_cast<void*>(0)) {}

Member Function Documentation

AddMemoryAllocationCallback()

void v8::internal::MemoryAllocator::AddMemoryAllocationCallback	(	MemoryAllocationCallback	callback,
		ObjectSpace	space,
		AllocationAction	action
	)

Definition at line 772 of file spaces.cc.

                             {
  DCHECK(callback != NULL);
  MemoryAllocationCallbackRegistration registration(callback, space, action);
  DCHECK(!MemoryAllocator::MemoryAllocationCallbackRegistered(callback));
  return memory_allocation_callbacks_.Add(registration);
}

References DCHECK, memory_allocation_callbacks_, MemoryAllocationCallbackRegistered(), NULL, and space().

Referenced by v8::V8::AddMemoryAllocationCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateAlignedMemory()

Address v8::internal::MemoryAllocator::AllocateAlignedMemory	(	size_t	reserve_size,
		size_t	commit_size,
		size_t	alignment,
		Executability	executable,
		base::VirtualMemory *	controller
	)

Definition at line 358 of file spaces.cc.

                                                             {
  DCHECK(commit_size <= reserve_size);
  base::VirtualMemory reservation;
  Address base = ReserveAlignedMemory(reserve_size, alignment, &reservation);
  if (base == NULL) return NULL;
 
  if (executable == EXECUTABLE) {
    if (!CommitExecutableMemory(&reservation, base, commit_size,
                                reserve_size)) {
      base = NULL;
    }
  } else {
    if (reservation.Commit(base, commit_size, false)) {
      UpdateAllocatedSpaceLimits(base, base + commit_size);
    } else {
      base = NULL;
    }
  }
 
  if (base == NULL) {
    // Failed to commit the body. Release the mapping and any partially
    // commited regions inside it.
    reservation.Release();
    return NULL;
  }
 
  controller->TakeControl(&reservation);
  return base;
}

References v8::base::VirtualMemory::Commit(), CommitExecutableMemory(), DCHECK, v8::internal::EXECUTABLE, NULL, v8::base::VirtualMemory::Release(), ReserveAlignedMemory(), v8::base::VirtualMemory::TakeControl(), and UpdateAllocatedSpaceLimits().

Referenced by AllocateChunk().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateChunk()

MemoryChunk * v8::internal::MemoryAllocator::AllocateChunk	(	intptr_t	reserve_area_size,
		intptr_t	commit_area_size,
		Executability	executable,
		Space *	space
	)

Definition at line 548 of file spaces.cc.

                                                          {
  DCHECK(commit_area_size <= reserve_area_size);
 
  size_t chunk_size;
  Heap* heap = isolate_->heap();
  Address base = NULL;
  base::VirtualMemory reservation;
  Address area_start = NULL;
  Address area_end = NULL;
 
  //
  // MemoryChunk layout:
  //
  //             Executable
  // +----------------------------+<- base aligned with MemoryChunk::kAlignment
  // |           Header           |
  // +----------------------------+<- base + CodePageGuardStartOffset
  // |           Guard            |
  // +----------------------------+<- area_start_
  // |           Area             |
  // +----------------------------+<- area_end_ (area_start + commit_area_size)
  // |   Committed but not used   |
  // +----------------------------+<- aligned at OS page boundary
  // | Reserved but not committed |
  // +----------------------------+<- aligned at OS page boundary
  // |           Guard            |
  // +----------------------------+<- base + chunk_size
  //
  //           Non-executable
  // +----------------------------+<- base aligned with MemoryChunk::kAlignment
  // |          Header            |
  // +----------------------------+<- area_start_ (base + kObjectStartOffset)
  // |           Area             |
  // +----------------------------+<- area_end_ (area_start + commit_area_size)
  // |  Committed but not used    |
  // +----------------------------+<- aligned at OS page boundary
  // | Reserved but not committed |
  // +----------------------------+<- base + chunk_size
  //
 
  if (executable == EXECUTABLE) {
    chunk_size = RoundUp(CodePageAreaStartOffset() + reserve_area_size,
                         base::OS::CommitPageSize()) +
                 CodePageGuardSize();
 
    // Check executable memory limit.
    if (size_executable_ + chunk_size > capacity_executable_) {
      LOG(isolate_, StringEvent("MemoryAllocator::AllocateRawMemory",
                                "V8 Executable Allocation capacity exceeded"));
      return NULL;
    }
 
    // Size of header (not executable) plus area (executable).
    size_t commit_size = RoundUp(CodePageGuardStartOffset() + commit_area_size,
                                 base::OS::CommitPageSize());
    // Allocate executable memory either from code range or from the
    // OS.
    if (isolate_->code_range() != NULL && isolate_->code_range()->valid()) {
      base = isolate_->code_range()->AllocateRawMemory(chunk_size, commit_size,
                                                       &chunk_size);
      DCHECK(
          IsAligned(reinterpret_cast<intptr_t>(base), MemoryChunk::kAlignment));
      if (base == NULL) return NULL;
      size_ += chunk_size;
      // Update executable memory size.
      size_executable_ += chunk_size;
    } else {
      base = AllocateAlignedMemory(chunk_size, commit_size,
                                   MemoryChunk::kAlignment, executable,
                                   &reservation);
      if (base == NULL) return NULL;
      // Update executable memory size.
      size_executable_ += reservation.size();
    }
 
    if (Heap::ShouldZapGarbage()) {
      ZapBlock(base, CodePageGuardStartOffset());
      ZapBlock(base + CodePageAreaStartOffset(), commit_area_size);
    }
 
    area_start = base + CodePageAreaStartOffset();
    area_end = area_start + commit_area_size;
  } else {
    chunk_size = RoundUp(MemoryChunk::kObjectStartOffset + reserve_area_size,
                         base::OS::CommitPageSize());
    size_t commit_size =
        RoundUp(MemoryChunk::kObjectStartOffset + commit_area_size,
                base::OS::CommitPageSize());
    base =
        AllocateAlignedMemory(chunk_size, commit_size, MemoryChunk::kAlignment,
                              executable, &reservation);
 
    if (base == NULL) return NULL;
 
    if (Heap::ShouldZapGarbage()) {
      ZapBlock(base, Page::kObjectStartOffset + commit_area_size);
    }
 
    area_start = base + Page::kObjectStartOffset;
    area_end = area_start + commit_area_size;
  }
 
  // Use chunk_size for statistics and callbacks because we assume that they
  // treat reserved but not-yet committed memory regions of chunks as allocated.
  isolate_->counters()->memory_allocated()->Increment(
      static_cast<int>(chunk_size));
 
  LOG(isolate_, NewEvent("MemoryChunk", base, chunk_size));
  if (owner != NULL) {
    ObjectSpace space = static_cast<ObjectSpace>(1 << owner->identity());
    PerformAllocationCallback(space, kAllocationActionAllocate, chunk_size);
  }
 
  MemoryChunk* result = MemoryChunk::Initialize(
      heap, base, chunk_size, area_start, area_end, executable, owner);
  result->set_reserved_memory(&reservation);
  return result;
}

References AllocateAlignedMemory(), v8::internal::CodeRange::AllocateRawMemory(), capacity_executable_, v8::internal::Isolate::code_range(), CodePageAreaStartOffset(), CodePageGuardSize(), CodePageGuardStartOffset(), v8::base::OS::CommitPageSize(), v8::internal::Isolate::counters(), DCHECK, v8::internal::EXECUTABLE, v8::internal::Isolate::heap(), v8::internal::Space::identity(), v8::internal::MemoryChunk::Initialize(), v8::internal::IsAligned(), isolate_, v8::internal::MemoryChunk::kAlignment, v8::kAllocationActionAllocate, v8::internal::MemoryChunk::kObjectStartOffset, LOG, NULL, PerformAllocationCallback(), v8::internal::RoundUp(), v8::internal::MemoryChunk::set_reserved_memory(), v8::internal::Heap::ShouldZapGarbage(), v8::base::VirtualMemory::size(), size_, size_executable_, space(), v8::internal::CodeRange::valid(), and ZapBlock().

Referenced by v8::internal::AllocateCodeChunk(), AllocateLargePage(), AllocatePage(), and v8::internal::PagedSpace::CreateEmergencyMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateLargePage()

LargePage * v8::internal::MemoryAllocator::AllocateLargePage	(	intptr_t	object_size,
		Space *	owner,
		Executability	executable
	)

Definition at line 690 of file spaces.cc.

                                                                        {
  MemoryChunk* chunk =
      AllocateChunk(object_size, object_size, executable, owner);
  if (chunk == NULL) return NULL;
  return LargePage::Initialize(isolate_->heap(), chunk);
}

References AllocateChunk(), v8::internal::Isolate::heap(), v8::internal::LargePage::Initialize(), isolate_, and NULL.

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

Here is the call graph for this function:

Here is the caller graph for this function:

AllocatePage()

Page * v8::internal::MemoryAllocator::AllocatePage	(	intptr_t	size,
		PagedSpace *	owner,
		Executability	executable
	)

Definition at line 680 of file spaces.cc.

                                                              {
  MemoryChunk* chunk = AllocateChunk(size, size, executable, owner);
 
  if (chunk == NULL) return NULL;
 
  return Page::Initialize(isolate_->heap(), chunk, executable, owner);
}

References AllocateChunk(), v8::internal::Isolate::heap(), v8::internal::Page::Initialize(), isolate_, NULL, and size.

Referenced by v8::internal::PagedSpace::Expand().

Here is the call graph for this function:

Here is the caller graph for this function:

Available()

intptr_t v8::internal::MemoryAllocator::Available ( )

inline

Definition at line 1020 of file spaces.h.

{ return capacity_ < size_ ? 0 : capacity_ - size_; }

References capacity_, and size_.

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

Here is the caller graph for this function:

AvailableExecutable()

intptr_t v8::internal::MemoryAllocator::AvailableExecutable ( )

inline

Definition at line 1026 of file spaces.h.

                                 {
    if (capacity_executable_ < size_executable_) return 0;
    return capacity_executable_ - size_executable_;
  }

References capacity_executable_, and size_executable_.

CodePageAreaEndOffset()

int v8::internal::MemoryAllocator::CodePageAreaEndOffset ( )

static

Definition at line 827 of file spaces.cc.

                                           {
  // We are guarding code pages: the last OS page will be protected as
  // non-writable.
  return Page::kPageSize - static_cast<int>(base::OS::CommitPageSize());
}

References v8::base::OS::CommitPageSize(), and v8::internal::Page::kPageSize.

Referenced by CodePageAreaSize().

Here is the call graph for this function:

Here is the caller graph for this function:

CodePageAreaSize()

static int v8::internal::MemoryAllocator::CodePageAreaSize ( )

inlinestatic

Definition at line 1103 of file spaces.h.

                                {
    return CodePageAreaEndOffset() - CodePageAreaStartOffset();
  }

References CodePageAreaEndOffset(), and CodePageAreaStartOffset().

Referenced by v8::internal::PagedSpace::PagedSpace(), and v8::internal::Serializer::SpaceAreaSize().

Here is the call graph for this function:

Here is the caller graph for this function:

CodePageAreaStartOffset()

int v8::internal::MemoryAllocator::CodePageAreaStartOffset ( )

static

Definition at line 820 of file spaces.cc.

                                             {
  // We are guarding code pages: the first OS page after the header
  // will be protected as non-writable.
  return CodePageGuardStartOffset() + CodePageGuardSize();
}

References CodePageGuardSize(), and CodePageGuardStartOffset().

Referenced by AllocateChunk(), CodePageAreaSize(), and CommitExecutableMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

CodePageGuardSize()

int v8::internal::MemoryAllocator::CodePageGuardSize ( )

static

Definition at line 815 of file spaces.cc.

                                       {
  return static_cast<int>(base::OS::CommitPageSize());
}

References v8::base::OS::CommitPageSize().

Referenced by AllocateChunk(), CodePageAreaStartOffset(), v8::internal::MemoryChunk::CommitArea(), and CommitExecutableMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

CodePageGuardStartOffset()

int v8::internal::MemoryAllocator::CodePageGuardStartOffset ( )

static

Definition at line 808 of file spaces.cc.

                                              {
  // We are guarding code pages: the first OS page after the header
  // will be protected as non-writable.
  return RoundUp(Page::kObjectStartOffset, base::OS::CommitPageSize());
}

References v8::base::OS::CommitPageSize(), v8::internal::MemoryChunk::kObjectStartOffset, and v8::internal::RoundUp().

Referenced by AllocateChunk(), CodePageAreaStartOffset(), and CommitExecutableMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

CommitBlock()

bool v8::internal::MemoryAllocator::CommitBlock	(	Address	start,
		size_t	size,
		Executability	executable
	)

Definition at line 723 of file spaces.cc.

                                                            {
  if (!CommitMemory(start, size, executable)) return false;
 
  if (Heap::ShouldZapGarbage()) {
    ZapBlock(start, size);
  }
 
  isolate_->counters()->memory_allocated()->Increment(static_cast<int>(size));
  return true;
}

References CommitMemory(), v8::internal::Isolate::counters(), isolate_, v8::internal::Heap::ShouldZapGarbage(), size, and ZapBlock().

Here is the call graph for this function:

CommitExecutableMemory()

bool v8::internal::MemoryAllocator::CommitExecutableMemory	(	base::VirtualMemory *	vm,
		Address	start,
		size_t	commit_size,
		size_t	reserved_size
	)

Definition at line 834 of file spaces.cc.

                                                                   {
  // Commit page header (not executable).
  if (!vm->Commit(start, CodePageGuardStartOffset(), false)) {
    return false;
  }
 
  // Create guard page after the header.
  if (!vm->Guard(start + CodePageGuardStartOffset())) {
    return false;
  }
 
  // Commit page body (executable).
  if (!vm->Commit(start + CodePageAreaStartOffset(),
                  commit_size - CodePageGuardStartOffset(), true)) {
    return false;
  }
 
  // Create guard page before the end.
  if (!vm->Guard(start + reserved_size - CodePageGuardSize())) {
    return false;
  }
 
  UpdateAllocatedSpaceLimits(start, start + CodePageAreaStartOffset() +
                                        commit_size -
                                        CodePageGuardStartOffset());
  return true;
}

References CodePageAreaStartOffset(), CodePageGuardSize(), CodePageGuardStartOffset(), v8::base::VirtualMemory::Commit(), v8::base::VirtualMemory::Guard(), and UpdateAllocatedSpaceLimits().

Referenced by AllocateAlignedMemory(), and v8::internal::CodeRange::AllocateRawMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

CommitMemory()

bool v8::internal::MemoryAllocator::CommitMemory	(	Address	addr,
		size_t	size,
		Executability	executable
	)

Definition at line 284 of file spaces.cc.

                                                             {
  if (!base::VirtualMemory::CommitRegion(base, size,
                                         executable == EXECUTABLE)) {
    return false;
  }
  UpdateAllocatedSpaceLimits(base, base + size);
  return true;
}

References v8::base::VirtualMemory::CommitRegion(), v8::internal::EXECUTABLE, size, and UpdateAllocatedSpaceLimits().

Referenced by CommitBlock(), and v8::internal::CodeRange::CommitRawMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::MemoryAllocator::DISALLOW_IMPLICIT_CONSTRUCTORS ( MemoryAllocator  )

private

Free()

void v8::internal::MemoryAllocator::Free

(

MemoryChunk *

chunk

)

Definition at line 700 of file spaces.cc.

                                             {
  LOG(isolate_, DeleteEvent("MemoryChunk", chunk));
  if (chunk->owner() != NULL) {
    ObjectSpace space =
        static_cast<ObjectSpace>(1 << chunk->owner()->identity());
    PerformAllocationCallback(space, kAllocationActionFree, chunk->size());
  }
 
  isolate_->heap()->RememberUnmappedPage(reinterpret_cast<Address>(chunk),
                                         chunk->IsEvacuationCandidate());
 
  delete chunk->slots_buffer();
  delete chunk->skip_list();
 
  base::VirtualMemory* reservation = chunk->reserved_memory();
  if (reservation->IsReserved()) {
    FreeMemory(reservation, chunk->executable());
  } else {
    FreeMemory(chunk->address(), chunk->size(), chunk->executable());
  }
}

References v8::internal::MemoryChunk::address(), v8::internal::MemoryChunk::executable(), FreeMemory(), v8::internal::Isolate::heap(), v8::internal::Space::identity(), v8::internal::MemoryChunk::IsEvacuationCandidate(), isolate_, v8::base::VirtualMemory::IsReserved(), v8::kAllocationActionFree, LOG, NULL, v8::internal::MemoryChunk::owner(), PerformAllocationCallback(), v8::internal::Heap::RememberUnmappedPage(), v8::internal::MemoryChunk::reserved_memory(), v8::internal::MemoryChunk::size(), v8::internal::MemoryChunk::skip_list(), v8::internal::MemoryChunk::slots_buffer(), and space().

Referenced by v8::internal::PagedSpace::FreeEmergencyMemory(), v8::internal::Heap::FreeQueuedChunks(), v8::internal::LargeObjectSpace::FreeUnmarkedObjects(), v8::internal::PagedSpace::ReleasePage(), v8::internal::PagedSpace::TearDown(), v8::internal::LargeObjectSpace::TearDown(), and v8::internal::DeoptimizerData::~DeoptimizerData().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeMemory() [1/2]

void v8::internal::MemoryAllocator::FreeMemory	(	Address	addr,
		size_t	size,
		Executability	executable
	)

Definition at line 319 of file spaces.cc.

                                                           {
  // TODO(gc) make code_range part of memory allocator?
  DCHECK(size_ >= size);
  size_ -= size;
 
  isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
 
  if (executable == EXECUTABLE) {
    DCHECK(size_executable_ >= size);
    size_executable_ -= size;
  }
  if (isolate_->code_range() != NULL &&
      isolate_->code_range()->contains(static_cast<Address>(base))) {
    DCHECK(executable == EXECUTABLE);
    isolate_->code_range()->FreeRawMemory(base, size);
  } else {
    DCHECK(executable == NOT_EXECUTABLE || isolate_->code_range() == NULL ||
           !isolate_->code_range()->valid());
    bool result = base::VirtualMemory::ReleaseRegion(base, size);
    USE(result);
    DCHECK(result);
  }
}

References v8::internal::Isolate::code_range(), v8::internal::CodeRange::contains(), v8::internal::Isolate::counters(), DCHECK, v8::internal::EXECUTABLE, v8::internal::CodeRange::FreeRawMemory(), isolate_, v8::internal::NOT_EXECUTABLE, NULL, v8::base::VirtualMemory::ReleaseRegion(), size, size_, size_executable_, USE(), and v8::internal::CodeRange::valid().

Here is the call graph for this function:

FreeMemory() [2/2]

void v8::internal::MemoryAllocator::FreeMemory	(	base::VirtualMemory *	reservation,
		Executability	executable
	)

Definition at line 295 of file spaces.cc.

                                                           {
  // TODO(gc) make code_range part of memory allocator?
  DCHECK(reservation->IsReserved());
  size_t size = reservation->size();
  DCHECK(size_ >= size);
  size_ -= size;
 
  isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
 
  if (executable == EXECUTABLE) {
    DCHECK(size_executable_ >= size);
    size_executable_ -= size;
  }
  // Code which is part of the code-range does not have its own VirtualMemory.
  DCHECK(isolate_->code_range() == NULL ||
         !isolate_->code_range()->contains(
             static_cast<Address>(reservation->address())));
  DCHECK(executable == NOT_EXECUTABLE || isolate_->code_range() == NULL ||
         !isolate_->code_range()->valid());
  reservation->Release();
}

References v8::base::VirtualMemory::address(), v8::internal::Isolate::code_range(), v8::internal::CodeRange::contains(), v8::internal::Isolate::counters(), DCHECK, v8::internal::EXECUTABLE, isolate_, v8::base::VirtualMemory::IsReserved(), v8::internal::NOT_EXECUTABLE, NULL, v8::base::VirtualMemory::Release(), v8::base::VirtualMemory::size(), size, size_, size_executable_, and v8::internal::CodeRange::valid().

Referenced by Free(), and v8::internal::NewSpace::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializePagesInChunk()

Page* v8::internal::MemoryAllocator::InitializePagesInChunk ( int  chunk_id, int  pages_in_chunk, PagedSpace *  owner  )

private

IsOutsideAllocatedSpace()

bool v8::internal::MemoryAllocator::IsOutsideAllocatedSpace ( const void *  address ) const

inline

Definition at line 1041 of file spaces.h.

                                                                    {
    return address < lowest_ever_allocated_ ||
           address >= highest_ever_allocated_;
  }

References highest_ever_allocated_, and lowest_ever_allocated_.

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

Here is the caller graph for this function:

MaxAvailable()

intptr_t v8::internal::MemoryAllocator::MaxAvailable ( )

inline

Definition at line 1035 of file spaces.h.

                          {
    return (Available() / Page::kPageSize) * Page::kMaxRegularHeapObjectSize;
  }

References Available(), v8::internal::Page::kMaxRegularHeapObjectSize, and v8::internal::Page::kPageSize.

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

Here is the call graph for this function:

Here is the caller graph for this function:

MemoryAllocationCallbackRegistered()

bool v8::internal::MemoryAllocator::MemoryAllocationCallbackRegistered

(

MemoryAllocationCallback

callback

)

Definition at line 763 of file spaces.cc.

                                       {
  for (int i = 0; i < memory_allocation_callbacks_.length(); ++i) {
    if (memory_allocation_callbacks_[i].callback == callback) return true;
  }
  return false;
}

References memory_allocation_callbacks_.

Referenced by AddMemoryAllocationCallback().

Here is the caller graph for this function:

PerformAllocationCallback()

void v8::internal::MemoryAllocator::PerformAllocationCallback	(	ObjectSpace	space,
		AllocationAction	action,
		size_t	size
	)

Definition at line 750 of file spaces.cc.

                                                             {
  for (int i = 0; i < memory_allocation_callbacks_.length(); ++i) {
    MemoryAllocationCallbackRegistration registration =
        memory_allocation_callbacks_[i];
    if ((registration.space & space) == space &&
        (registration.action & action) == action)
      registration.callback(space, action, static_cast<int>(size));
  }
}

References v8::internal::MemoryAllocator::MemoryAllocationCallbackRegistration::action, v8::internal::MemoryAllocator::MemoryAllocationCallbackRegistration::callback, memory_allocation_callbacks_, size, space(), and v8::internal::MemoryAllocator::MemoryAllocationCallbackRegistration::space.

Referenced by AllocateChunk(), Free(), and v8::internal::LargeObjectSpace::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveMemoryAllocationCallback()

void v8::internal::MemoryAllocator::RemoveMemoryAllocationCallback

(

MemoryAllocationCallback

callback

)

Definition at line 782 of file spaces.cc.

                                       {
  DCHECK(callback != NULL);
  for (int i = 0; i < memory_allocation_callbacks_.length(); ++i) {
    if (memory_allocation_callbacks_[i].callback == callback) {
      memory_allocation_callbacks_.Remove(i);
      return;
    }
  }
  UNREACHABLE();
}

References DCHECK, memory_allocation_callbacks_, NULL, and UNREACHABLE.

Referenced by v8::V8::RemoveMemoryAllocationCallback().

Here is the caller graph for this function:

ReserveAlignedMemory()

Address v8::internal::MemoryAllocator::ReserveAlignedMemory	(	size_t	requested,
		size_t	alignment,
		base::VirtualMemory *	controller
	)

Definition at line 345 of file spaces.cc.

                                                                             {
  base::VirtualMemory reservation(size, alignment);
 
  if (!reservation.IsReserved()) return NULL;
  size_ += reservation.size();
  Address base =
      RoundUp(static_cast<Address>(reservation.address()), alignment);
  controller->TakeControl(&reservation);
  return base;
}

References v8::base::VirtualMemory::address(), v8::base::VirtualMemory::IsReserved(), NULL, v8::internal::RoundUp(), v8::base::VirtualMemory::size(), size, size_, and v8::base::VirtualMemory::TakeControl().

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetUp()

bool v8::internal::MemoryAllocator::SetUp	(	intptr_t	max_capacity,
		intptr_t	capacity_executable
	)

Definition at line 262 of file spaces.cc.

                                                                           {
  capacity_ = RoundUp(capacity, Page::kPageSize);
  capacity_executable_ = RoundUp(capacity_executable, Page::kPageSize);
  DCHECK_GE(capacity_, capacity_executable_);
 
  size_ = 0;
  size_executable_ = 0;
 
  return true;
}

References capacity_, capacity_executable_, DCHECK_GE, v8::internal::Page::kPageSize, v8::internal::RoundUp(), size_, and size_executable_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Size()

intptr_t v8::internal::MemoryAllocator::Size ( )

inline

Definition at line 1023 of file spaces.h.

{ return size_; }

References size_.

Referenced by v8::internal::StatisticsExtension::GetCounters(), v8::internal::Heap::PrintShortHeapStatistics(), v8::internal::Heap::RecordStats(), v8::internal::GCTracer::Start(), and v8::internal::GCTracer::Stop().

Here is the caller graph for this function:

SizeExecutable()

intptr_t v8::internal::MemoryAllocator::SizeExecutable ( )

inline

Definition at line 1032 of file spaces.h.

{ return size_executable_; }

References size_executable_.

Referenced by v8::internal::RegExpCompiler::Assemble(), and v8::internal::Heap::CommittedMemoryExecutable().

Here is the caller graph for this function:

TearDown()

void v8::internal::MemoryAllocator::TearDown

(

)

Definition at line 274 of file spaces.cc.

                               {
  // Check that spaces were torn down before MemoryAllocator.
  DCHECK(size_ == 0);
  // TODO(gc) this will be true again when we fix FreeMemory.
  // DCHECK(size_executable_ == 0);
  capacity_ = 0;
  capacity_executable_ = 0;
}

References capacity_, capacity_executable_, DCHECK, and size_.

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

Here is the caller graph for this function:

UncommitBlock()

bool v8::internal::MemoryAllocator::UncommitBlock	(	Address	start,
		size_t	size
	)

Definition at line 736 of file spaces.cc.

                                                              {
  if (!base::VirtualMemory::UncommitRegion(start, size)) return false;
  isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
  return true;
}

References v8::internal::Isolate::counters(), isolate_, size, and v8::base::VirtualMemory::UncommitRegion().

Referenced by v8::internal::SemiSpace::ShrinkTo().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateAllocatedSpaceLimits()

void v8::internal::MemoryAllocator::UpdateAllocatedSpaceLimits ( void *  low, void *  high  )

inlineprivate

Definition at line 1152 of file spaces.h.

                                                         {
    lowest_ever_allocated_ = Min(lowest_ever_allocated_, low);
    highest_ever_allocated_ = Max(highest_ever_allocated_, high);
  }

References highest_ever_allocated_, lowest_ever_allocated_, v8::internal::Max(), and v8::internal::Min().

Referenced by AllocateAlignedMemory(), CommitExecutableMemory(), and CommitMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

ZapBlock()

void v8::internal::MemoryAllocator::ZapBlock	(	Address	start,
		size_t	size
	)

Definition at line 743 of file spaces.cc.

                                                         {
  for (size_t s = 0; s + kPointerSize <= size; s += kPointerSize) {
    Memory::Address_at(start + s) = kZapValue;
  }
}

References v8::internal::Memory::Address_at(), v8::internal::kPointerSize, v8::internal::kZapValue, and size.

Referenced by AllocateChunk(), v8::internal::MemoryChunk::CommitArea(), and CommitBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

capacity_

size_t v8::internal::MemoryAllocator::capacity_

private

Definition at line 1115 of file spaces.h.

Referenced by Available(), SetUp(), and TearDown().

capacity_executable_

size_t v8::internal::MemoryAllocator::capacity_executable_

private

Definition at line 1117 of file spaces.h.

Referenced by AllocateChunk(), AvailableExecutable(), SetUp(), and TearDown().

highest_ever_allocated_

void* v8::internal::MemoryAllocator::highest_ever_allocated_

private

Definition at line 1130 of file spaces.h.

Referenced by IsOutsideAllocatedSpace(), and UpdateAllocatedSpaceLimits().

isolate_

Isolate* v8::internal::MemoryAllocator::isolate_

private

Definition at line 1112 of file spaces.h.

Referenced by AllocateChunk(), AllocateLargePage(), AllocatePage(), CommitBlock(), Free(), FreeMemory(), and UncommitBlock().

lowest_ever_allocated_

void* v8::internal::MemoryAllocator::lowest_ever_allocated_

private

Definition at line 1129 of file spaces.h.

Referenced by IsOutsideAllocatedSpace(), and UpdateAllocatedSpaceLimits().

memory_allocation_callbacks_

List<MemoryAllocationCallbackRegistration> v8::internal::MemoryAllocator::memory_allocation_callbacks_

private

Definition at line 1143 of file spaces.h.

Referenced by AddMemoryAllocationCallback(), MemoryAllocationCallbackRegistered(), PerformAllocationCallback(), and RemoveMemoryAllocationCallback().

size_

size_t v8::internal::MemoryAllocator::size_

private

Definition at line 1120 of file spaces.h.

Referenced by AllocateChunk(), Available(), FreeMemory(), ReserveAlignedMemory(), SetUp(), Size(), and TearDown().

size_executable_

size_t v8::internal::MemoryAllocator::size_executable_

private

Definition at line 1122 of file spaces.h.

Referenced by AllocateChunk(), AvailableExecutable(), FreeMemory(), SetUp(), and SizeExecutable().

---

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

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