v8::internal::CodeRange Class Reference

#include <spaces.h>

Collaboration diagram for v8::internal::CodeRange:

Classes
class	FreeBlock

Public Member Functions
	CodeRange (Isolate *isolate)
	~CodeRange ()
bool	SetUp (size_t requested_size)
void	TearDown ()
bool	valid ()
Address	start ()
size_t	size ()
bool	contains (Address address)
MUST_USE_RESULT Address	AllocateRawMemory (const size_t requested_size, const size_t commit_size, size_t *allocated)
bool	CommitRawMemory (Address start, size_t length)
bool	UncommitRawMemory (Address start, size_t length)
void	FreeRawMemory (Address buf, size_t length)

Private Member Functions
bool	GetNextAllocationBlock (size_t requested)
	DISALLOW_COPY_AND_ASSIGN (CodeRange)

Static Private Member Functions
static int	CompareFreeBlockAddress (const FreeBlock *left, const FreeBlock *right)

Private Attributes
Isolate *	isolate_
base::VirtualMemory *	code_range_
List< FreeBlock >	free_list_
List< FreeBlock >	allocation_list_
int	current_allocation_block_index_

Detailed Description

Definition at line 864 of file spaces.h.

Constructor & Destructor Documentation

CodeRange()

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

explicit

Definition at line 91 of file spaces.cc.

    : isolate_(isolate),
      code_range_(NULL),
      free_list_(0),
      allocation_list_(0),
      current_allocation_block_index_(0) {}

~CodeRange()

v8::internal::CodeRange::~CodeRange ( )

inline

Definition at line 867 of file spaces.h.

{ TearDown(); }

References TearDown().

Here is the call graph for this function:

Member Function Documentation

AllocateRawMemory()

Address v8::internal::CodeRange::AllocateRawMemory	(	const size_t	requested_size,
		const size_t	commit_size,
		size_t *	allocated
	)

Definition at line 186 of file spaces.cc.

                                                        {
  DCHECK(commit_size <= requested_size);
  DCHECK(allocation_list_.length() == 0 ||
         current_allocation_block_index_ < allocation_list_.length());
  if (allocation_list_.length() == 0 ||
      requested_size > allocation_list_[current_allocation_block_index_].size) {
    // Find an allocation block large enough.
    if (!GetNextAllocationBlock(requested_size)) return NULL;
  }
  // Commit the requested memory at the start of the current allocation block.
  size_t aligned_requested = RoundUp(requested_size, MemoryChunk::kAlignment);
  FreeBlock current = allocation_list_[current_allocation_block_index_];
  if (aligned_requested >= (current.size - Page::kPageSize)) {
    // Don't leave a small free block, useless for a large object or chunk.
    *allocated = current.size;
  } else {
    *allocated = aligned_requested;
  }
  DCHECK(*allocated <= current.size);
  DCHECK(IsAddressAligned(current.start, MemoryChunk::kAlignment));
  if (!isolate_->memory_allocator()->CommitExecutableMemory(
          code_range_, current.start, commit_size, *allocated)) {
    *allocated = 0;
    return NULL;
  }
  allocation_list_[current_allocation_block_index_].start += *allocated;
  allocation_list_[current_allocation_block_index_].size -= *allocated;
  if (*allocated == current.size) {
    // This block is used up, get the next one.
    GetNextAllocationBlock(0);
  }
  return current.start;
}

References allocation_list_, code_range_, v8::internal::MemoryAllocator::CommitExecutableMemory(), current_allocation_block_index_, DCHECK, GetNextAllocationBlock(), v8::internal::IsAddressAligned(), isolate_, v8::internal::MemoryChunk::kAlignment, v8::internal::Page::kPageSize, v8::internal::Isolate::memory_allocator(), NULL, v8::internal::RoundUp(), v8::internal::CodeRange::FreeBlock::size, and v8::internal::CodeRange::FreeBlock::start.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CommitRawMemory()

bool v8::internal::CodeRange::CommitRawMemory	(	Address	start,
		size_t	length
	)

Definition at line 223 of file spaces.cc.

                                                            {
  return isolate_->memory_allocator()->CommitMemory(start, length, EXECUTABLE);
}

References v8::internal::MemoryAllocator::CommitMemory(), v8::internal::EXECUTABLE, isolate_, v8::internal::Isolate::memory_allocator(), and start().

Referenced by v8::internal::MemoryChunk::CommitArea().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareFreeBlockAddress()

int v8::internal::CodeRange::CompareFreeBlockAddress ( const FreeBlock *  left, const FreeBlock *  right  )

staticprivate

Definition at line 136 of file spaces.cc.

                                                               {
  // The entire point of CodeRange is that the difference between two
  // addresses in the range can be represented as a signed 32-bit int,
  // so the cast is semantically correct.
  return static_cast<int>(left->start - right->start);
}

References v8::internal::CodeRange::FreeBlock::start.

Referenced by GetNextAllocationBlock().

Here is the caller graph for this function:

contains()

bool v8::internal::CodeRange::contains ( Address  address )

inline

Definition at line 887 of file spaces.h.

                                 {
    if (!valid()) return false;
    Address start = static_cast<Address>(code_range_->address());
    return start <= address && address < start + code_range_->size();
  }

References v8::base::VirtualMemory::address(), code_range_, v8::base::VirtualMemory::size(), start(), and valid().

Referenced by v8::internal::Heap::AllocateCode(), v8::internal::Heap::CopyCode(), and v8::internal::MemoryAllocator::FreeMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::CodeRange::DISALLOW_COPY_AND_ASSIGN ( CodeRange  )

private

FreeRawMemory()

void v8::internal::CodeRange::FreeRawMemory	(	Address	buf,
		size_t	length
	)

Definition at line 233 of file spaces.cc.

                                                            {
  DCHECK(IsAddressAligned(address, MemoryChunk::kAlignment));
  free_list_.Add(FreeBlock(address, length));
  code_range_->Uncommit(address, length);
}

References code_range_, DCHECK, free_list_, v8::internal::IsAddressAligned(), v8::internal::MemoryChunk::kAlignment, and v8::base::VirtualMemory::Uncommit().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetNextAllocationBlock()

bool v8::internal::CodeRange::GetNextAllocationBlock ( size_t  requested )

private

Definition at line 145 of file spaces.cc.

                                                       {
  for (current_allocation_block_index_++;
       current_allocation_block_index_ < allocation_list_.length();
       current_allocation_block_index_++) {
    if (requested <= allocation_list_[current_allocation_block_index_].size) {
      return true;  // Found a large enough allocation block.
    }
  }
 
  // Sort and merge the free blocks on the free list and the allocation list.
  free_list_.AddAll(allocation_list_);
  allocation_list_.Clear();
  free_list_.Sort(&CompareFreeBlockAddress);
  for (int i = 0; i < free_list_.length();) {
    FreeBlock merged = free_list_[i];
    i++;
    // Add adjacent free blocks to the current merged block.
    while (i < free_list_.length() &&
           free_list_[i].start == merged.start + merged.size) {
      merged.size += free_list_[i].size;
      i++;
    }
    if (merged.size > 0) {
      allocation_list_.Add(merged);
    }
  }
  free_list_.Clear();
 
  for (current_allocation_block_index_ = 0;
       current_allocation_block_index_ < allocation_list_.length();
       current_allocation_block_index_++) {
    if (requested <= allocation_list_[current_allocation_block_index_].size) {
      return true;  // Found a large enough allocation block.
    }
  }
  current_allocation_block_index_ = 0;
  // Code range is full or too fragmented.
  return false;
}

References allocation_list_, CompareFreeBlockAddress(), current_allocation_block_index_, free_list_, size(), v8::internal::CodeRange::FreeBlock::size, and v8::internal::CodeRange::FreeBlock::start.

Referenced by AllocateRawMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUp()

bool v8::internal::CodeRange::SetUp

(

size_t

requested_size

)

Definition at line 99 of file spaces.cc.

                                      {
  DCHECK(code_range_ == NULL);
 
  if (requested == 0) {
    // When a target requires the code range feature, we put all code objects
    // in a kMaximalCodeRangeSize range of virtual address space, so that
    // they can call each other with near calls.
    if (kRequiresCodeRange) {
      requested = kMaximalCodeRangeSize;
    } else {
      return true;
    }
  }
 
  DCHECK(!kRequiresCodeRange || requested <= kMaximalCodeRangeSize);
  code_range_ = new base::VirtualMemory(requested);
  CHECK(code_range_ != NULL);
  if (!code_range_->IsReserved()) {
    delete code_range_;
    code_range_ = NULL;
    return false;
  }
 
  // We are sure that we have mapped a block of requested addresses.
  DCHECK(code_range_->size() == requested);
  LOG(isolate_, NewEvent("CodeRange", code_range_->address(), requested));
  Address base = reinterpret_cast<Address>(code_range_->address());
  Address aligned_base =
      RoundUp(reinterpret_cast<Address>(code_range_->address()),
              MemoryChunk::kAlignment);
  size_t size = code_range_->size() - (aligned_base - base);
  allocation_list_.Add(FreeBlock(aligned_base, size));
  current_allocation_block_index_ = 0;
  return true;
}

References v8::base::VirtualMemory::address(), allocation_list_, CHECK, code_range_, current_allocation_block_index_, DCHECK, isolate_, v8::base::VirtualMemory::IsReserved(), v8::internal::MemoryChunk::kAlignment, v8::internal::kMaximalCodeRangeSize, v8::internal::kRequiresCodeRange, LOG, NULL, v8::internal::RoundUp(), v8::base::VirtualMemory::size(), and size().

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

Here is the call graph for this function:

Here is the caller graph for this function:

size()

size_t v8::internal::CodeRange::size ( )

inline

Definition at line 883 of file spaces.h.

                {
    DCHECK(valid());
    return code_range_->size();
  }

References code_range_, DCHECK, v8::base::VirtualMemory::size(), and valid().

Referenced by v8::Isolate::GetCodeRange(), GetNextAllocationBlock(), and SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

start()

Address v8::internal::CodeRange::start ( )

inline

Definition at line 879 of file spaces.h.

                  {
    DCHECK(valid());
    return static_cast<Address>(code_range_->address());
  }

References v8::base::VirtualMemory::address(), code_range_, DCHECK, and valid().

Referenced by CommitRawMemory(), contains(), v8::Isolate::GetCodeRange(), v8::internal::Assembler::runtime_entry_at(), and UncommitRawMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

TearDown()

void v8::internal::CodeRange::TearDown

(

)

Definition at line 240 of file spaces.cc.

                         {
  delete code_range_;  // Frees all memory in the virtual memory range.
  code_range_ = NULL;
  free_list_.Free();
  allocation_list_.Free();
}

References allocation_list_, code_range_, free_list_, and NULL.

Referenced by ~CodeRange().

Here is the caller graph for this function:

UncommitRawMemory()

bool v8::internal::CodeRange::UncommitRawMemory	(	Address	start,
		size_t	length
	)

Definition at line 228 of file spaces.cc.

                                                              {
  return code_range_->Uncommit(start, length);
}

References code_range_, start(), and v8::base::VirtualMemory::Uncommit().

Referenced by v8::internal::MemoryChunk::CommitArea().

Here is the call graph for this function:

Here is the caller graph for this function:

valid()

bool v8::internal::CodeRange::valid ( )

inline

Definition at line 878 of file spaces.h.

{ return code_range_ != NULL; }

References code_range_, and NULL.

Referenced by v8::internal::MemoryAllocator::AllocateChunk(), v8::internal::Heap::AllocateCode(), v8::internal::MemoryChunk::CommitArea(), contains(), v8::internal::Heap::CopyCode(), v8::internal::MemoryAllocator::FreeMemory(), v8::Isolate::GetCodeRange(), size(), v8::internal::PagedSpace::SizeOfFirstPage(), and start().

Here is the caller graph for this function:

Member Data Documentation

allocation_list_

List<FreeBlock> v8::internal::CodeRange::allocation_list_

private

Definition at line 932 of file spaces.h.

Referenced by AllocateRawMemory(), GetNextAllocationBlock(), SetUp(), and TearDown().

code_range_

base::VirtualMemory* v8::internal::CodeRange::code_range_

private

Definition at line 907 of file spaces.h.

Referenced by AllocateRawMemory(), contains(), FreeRawMemory(), SetUp(), size(), start(), TearDown(), UncommitRawMemory(), and valid().

current_allocation_block_index_

int v8::internal::CodeRange::current_allocation_block_index_

private

Definition at line 933 of file spaces.h.

Referenced by AllocateRawMemory(), GetNextAllocationBlock(), and SetUp().

free_list_

List<FreeBlock> v8::internal::CodeRange::free_list_

private

Definition at line 929 of file spaces.h.

Referenced by FreeRawMemory(), GetNextAllocationBlock(), and TearDown().

isolate_

Isolate* v8::internal::CodeRange::isolate_

private

Definition at line 904 of file spaces.h.

Referenced by AllocateRawMemory(), CommitRawMemory(), and SetUp().

---

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

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