v8::ResourceConstraints Class Reference

#include <v8-isolate.h>

Public Member Functions
void	ConfigureDefaultsFromHeapSize (size_t initial_heap_size_in_bytes, size_t maximum_heap_size_in_bytes)
void	ConfigureDefaults (uint64_t physical_memory, uint64_t virtual_memory_limit)
uint32_t *	stack_limit () const
void	set_stack_limit (uint32_t *value)
size_t	code_range_size_in_bytes () const
void	set_code_range_size_in_bytes (size_t limit)
size_t	max_old_generation_size_in_bytes () const
void	set_max_old_generation_size_in_bytes (size_t limit)
size_t	max_young_generation_size_in_bytes () const
void	set_max_young_generation_size_in_bytes (size_t limit)
size_t	initial_old_generation_size_in_bytes () const
void	set_initial_old_generation_size_in_bytes (size_t initial_size)
size_t	initial_young_generation_size_in_bytes () const
void	set_initial_young_generation_size_in_bytes (size_t initial_size)

Detailed Description

A set of constraints that specifies the limits of the runtime's memory use. You must set the heap size before initializing the VM - the size cannot be adjusted after the VM is initialized.

If you are using threads then you should hold the V8::Locker lock while setting the stack limit and you must set a non-default stack limit separately for each thread.

The arguments for set_max_semi_space_size, set_max_old_space_size, set_max_executable_size, set_code_range_size specify limits in MB.

The argument for set_max_semi_space_size_in_kb is in KB.

Member Function Documentation

code_range_size_in_bytes()

size_t v8::ResourceConstraints::code_range_size_in_bytes ( ) const

inline

The amount of virtual memory reserved for generated code. This is relevant for 64-bit architectures that rely on code range for calls in code.

When V8_COMPRESS_POINTERS_IN_SHARED_CAGE is defined, there is a shared process-wide code range that is lazily initialized. This value is used to configure that shared code range when the first Isolate is created. Subsequent Isolates ignore this value.

ConfigureDefaults()

void v8::ResourceConstraints::ConfigureDefaults	(	uint64_t	physical_memory,
		uint64_t	virtual_memory_limit
	)

Configures the constraints with reasonable default values based on the capabilities of the current device the VM is running on.

Parameters

physical_memory	The total amount of physical memory on the current device, in bytes.
virtual_memory_limit	The amount of virtual memory on the current device, in bytes, or zero, if there is no limit.

ConfigureDefaultsFromHeapSize()

void v8::ResourceConstraints::ConfigureDefaultsFromHeapSize	(	size_t	initial_heap_size_in_bytes,
		size_t	maximum_heap_size_in_bytes
	)

Configures the constraints with reasonable default values based on the provided heap size limit. The heap size includes both the young and the old generation.

Parameters

initial_heap_size_in_bytes	The initial heap size or zero. By default V8 starts with a small heap and dynamically grows it to match the set of live objects. This may lead to ineffective garbage collections at startup if the live set is large. Setting the initial heap size avoids such garbage collections. Note that this does not affect young generation garbage collections.
maximum_heap_size_in_bytes	The hard limit for the heap size. When the heap size approaches this limit, V8 will perform series of garbage collections and invoke the NearHeapLimitCallback. If the garbage collections do not help and the callback does not increase the limit, then V8 will crash with V8::FatalProcessOutOfMemory.

initial_old_generation_size_in_bytes()

size_t v8::ResourceConstraints::initial_old_generation_size_in_bytes ( ) const

inline

initial_young_generation_size_in_bytes()

size_t v8::ResourceConstraints::initial_young_generation_size_in_bytes ( ) const

inline

max_old_generation_size_in_bytes()

size_t v8::ResourceConstraints::max_old_generation_size_in_bytes ( ) const

inline

The maximum size of the old generation. When the old generation approaches this limit, V8 will perform series of garbage collections and invoke the NearHeapLimitCallback. If the garbage collections do not help and the callback does not increase the limit, then V8 will crash with V8::FatalProcessOutOfMemory.

max_young_generation_size_in_bytes()

size_t v8::ResourceConstraints::max_young_generation_size_in_bytes ( ) const

inline

The maximum size of the young generation, which consists of two semi-spaces and a large object space. This affects frequency of Scavenge garbage collections and should be typically much smaller that the old generation.

set_code_range_size_in_bytes()

void v8::ResourceConstraints::set_code_range_size_in_bytes ( size_t  limit )

inline

set_initial_old_generation_size_in_bytes()

void v8::ResourceConstraints::set_initial_old_generation_size_in_bytes ( size_t  initial_size )

inline

set_initial_young_generation_size_in_bytes()

void v8::ResourceConstraints::set_initial_young_generation_size_in_bytes ( size_t  initial_size )

inline

set_max_old_generation_size_in_bytes()

void v8::ResourceConstraints::set_max_old_generation_size_in_bytes ( size_t  limit )

inline

set_max_young_generation_size_in_bytes()

void v8::ResourceConstraints::set_max_young_generation_size_in_bytes ( size_t  limit )

inline

set_stack_limit()

void v8::ResourceConstraints::set_stack_limit ( uint32_t *  value )

inline

stack_limit()

uint32_t * v8::ResourceConstraints::stack_limit ( ) const

inline

The address beyond which the VM's stack may not grow.

---

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

• include/v8-isolate.h