v8::Isolate Class Reference

Isolate represents an isolated instance of the V8 engine. More...

#include <v8.h>

Collaboration diagram for v8::Isolate:

Classes
class	AllowJavascriptExecutionScope
	Introduce exception to DisallowJavascriptExecutionScope. More...
struct	CreateParams
	Initial configuration parameters for a new Isolate. More...
class	DisallowJavascriptExecutionScope
	Assert that no Javascript code is invoked. More...
class	Scope
	Stack-allocated class which sets the isolate for all operations executed within a local scope. More...
class	SuppressMicrotaskExecutionScope
	Do not run microtasks while this scope is active, even if microtasks are automatically executed otherwise. More...

Public Types
enum	GarbageCollectionType { kFullGarbageCollection , kMinorGarbageCollection }
	Types of garbage collections that can be requested via RequestGarbageCollectionForTesting. More...
enum	UseCounterFeature { kUseAsm = 0 , kUseCounterFeatureCount }
	Features reported via the SetUseCounterCallback callback. More...
typedef void(*	UseCounterCallback) (Isolate *isolate, UseCounterFeature feature)
typedef void(*	GCPrologueCallback) (Isolate *isolate, GCType type, GCCallbackFlags flags)
typedef void(*	GCEpilogueCallback) (Isolate *isolate, GCType type, GCCallbackFlags flags)

Public Member Functions
void	Enter ()
	Methods below this point require holding a lock (using Locker) in a multi-threaded environment. More...
void	Exit ()
	Exits this isolate by restoring the previously entered one in the current thread. More...
void	Dispose ()
	Disposes the isolate. More...
void	SetData (uint32_t slot, void *data)
	Associate embedder-specific data with the isolate. More...
void *	GetData (uint32_t slot)
	Retrieve embedder-specific data from the isolate. More...
void	GetHeapStatistics (HeapStatistics *heap_statistics)
	Get statistics about the heap memory usage. More...
int64_t	AdjustAmountOfExternalAllocatedMemory (int64_t change_in_bytes)
	Adjusts the amount of registered external memory. More...
HeapProfiler *	GetHeapProfiler ()
	Returns heap profiler for this isolate. More...
CpuProfiler *	GetCpuProfiler ()
	Returns CPU profiler for this isolate. More...
bool	InContext ()
	Returns true if this isolate has a current context. More...
Local< Context >	GetCurrentContext ()
	Returns the context that is on the top of the stack. More...
Local< Context >	GetCallingContext ()
	Returns the context of the calling JavaScript code. More...
Local< Context >	GetEnteredContext ()
	Returns the last entered context. More...
Local< Value >	ThrowException (Local< Value > exception)
	Schedules an exception to be thrown when returning to JavaScript. More...
template<typename T >
void	SetObjectGroupId (const Persistent< T > &object, UniqueId id)
	Allows the host application to group objects together. More...
template<typename T >
void	SetReferenceFromGroup (UniqueId id, const Persistent< T > &child)
	Allows the host application to declare implicit references from an object group to an object. More...
template<typename T , typename S >
void	SetReference (const Persistent< T > &parent, const Persistent< S > &child)
	Allows the host application to declare implicit references from an object to another object. More...
void	AddGCPrologueCallback (GCPrologueCallback callback, GCType gc_type_filter=kGCTypeAll)
	Enables the host application to receive a notification before a garbage collection. More...
void	RemoveGCPrologueCallback (GCPrologueCallback callback)
	This function removes callback which was installed by AddGCPrologueCallback function. More...
void	AddGCEpilogueCallback (GCEpilogueCallback callback, GCType gc_type_filter=kGCTypeAll)
	Enables the host application to receive a notification after a garbage collection. More...
void	RemoveGCEpilogueCallback (GCEpilogueCallback callback)
	This function removes callback which was installed by AddGCEpilogueCallback function. More...
void	RequestInterrupt (InterruptCallback callback, void *data)
	Request V8 to interrupt long running JavaScript code and invoke the given |callback| passing the given |data| to it. More...
void	ClearInterrupt ()
	Clear interrupt request created by |RequestInterrupt|. More...
void	RequestGarbageCollectionForTesting (GarbageCollectionType type)
	Request garbage collection in this Isolate. More...
void	SetEventLogger (LogEventCallback that)
	Set the callback to invoke for logging event. More...
void	AddCallCompletedCallback (CallCompletedCallback callback)
	Adds a callback to notify the host application when a script finished running. More...
void	RemoveCallCompletedCallback (CallCompletedCallback callback)
	Removes callback that was installed by AddCallCompletedCallback. More...
void	RunMicrotasks ()
	Experimental: Runs the Microtask Work Queue until empty Any exceptions thrown by microtask callbacks are swallowed. More...
void	EnqueueMicrotask (Handle< Function > microtask)
	Experimental: Enqueues the callback to the Microtask Work Queue. More...
void	EnqueueMicrotask (MicrotaskCallback microtask, void *data=NULL)
	Experimental: Enqueues the callback to the Microtask Work Queue. More...
void	SetAutorunMicrotasks (bool autorun)
	Experimental: Controls whether the Microtask Work Queue is automatically run when the script call depth decrements to zero. More...
bool	WillAutorunMicrotasks () const
	Experimental: Returns whether the Microtask Work Queue is automatically run when the script call depth decrements to zero. More...
void	SetUseCounterCallback (UseCounterCallback callback)
	Sets a callback for counting the number of times a feature of V8 is used. More...
void	SetCounterFunction (CounterLookupCallback)
	Enables the host application to provide a mechanism for recording statistics counters. More...
void	SetCreateHistogramFunction (CreateHistogramCallback)
	Enables the host application to provide a mechanism for recording histograms. More...
void	SetAddHistogramSampleFunction (AddHistogramSampleCallback)
bool	IdleNotification (int idle_time_in_ms)
	Optional notification that the embedder is idle. More...
void	LowMemoryNotification ()
	Optional notification that the system is running low on memory. More...
int	ContextDisposedNotification ()
	Optional notification that a context has been disposed. More...
void	SetJitCodeEventHandler (JitCodeEventOptions options, JitCodeEventHandler event_handler)
	Allows the host application to provide the address of a function that is notified each time code is added, moved or removed. More...
void	SetStackLimit (uintptr_t stack_limit)
	Modifies the stack limit for this Isolate. More...
void	GetCodeRange (void **start, size_t *length_in_bytes)
	Returns a memory range that can potentially contain jitted code. More...

Static Public Member Functions
static Isolate *	New (const CreateParams &params=CreateParams())
	Creates a new isolate. More...
static Isolate *	GetCurrent ()
	Returns the entered isolate for the current thread or NULL in case there is no current isolate. More...
static uint32_t	GetNumberOfDataSlots ()
	Returns the maximum number of available embedder data slots. More...

Private Member Functions
	Isolate ()
	Isolate (const Isolate &)
	~Isolate ()
Isolate &	operator= (const Isolate &)
void *	operator new (size_t size)
void	operator delete (void *, size_t)
void	SetObjectGroupId (internal::Object **object, UniqueId id)
void	SetReferenceFromGroup (UniqueId id, internal::Object **object)
void	SetReference (internal::Object **parent, internal::Object **child)
void	CollectAllGarbage (const char *gc_reason)

Friends
template<class K , class V , class Traits >
class	PersistentValueMap

Detailed Description

Isolate represents an isolated instance of the V8 engine.

V8 isolates have completely separate states. Objects from one isolate must not be used in other isolates. The embedder can create multiple isolates and use them in parallel in multiple threads. An isolate can be entered by at most one thread at any given time. The Locker/Unlocker API must be used to synchronize.

Definition at line 4356 of file v8.h.

Member Typedef Documentation

GCEpilogueCallback

typedef void(* v8::Isolate::GCEpilogueCallback) (Isolate *isolate, GCType type, GCCallbackFlags flags)

Definition at line 4651 of file v8.h.

GCPrologueCallback

typedef void(* v8::Isolate::GCPrologueCallback) (Isolate *isolate, GCType type, GCCallbackFlags flags)

Definition at line 4648 of file v8.h.

UseCounterCallback

typedef void(* v8::Isolate::UseCounterCallback) (Isolate *isolate, UseCounterFeature feature)

Definition at line 4491 of file v8.h.

Member Enumeration Documentation

GarbageCollectionType

enum v8::Isolate::GarbageCollectionType

Types of garbage collections that can be requested via RequestGarbageCollectionForTesting.

Enumerator
kFullGarbageCollection
kMinorGarbageCollection

Definition at line 4476 of file v8.h.

                             {
    kFullGarbageCollection,
    kMinorGarbageCollection
  };

UseCounterFeature

enum v8::Isolate::UseCounterFeature

Features reported via the SetUseCounterCallback callback.

Do not chang assigned numbers of existing items; add new features to the end of this list.

Enumerator
kUseAsm
kUseCounterFeatureCount

Definition at line 4486 of file v8.h.

                         {
    kUseAsm = 0,
    kUseCounterFeatureCount  // This enum value must be last.
  };

Constructor & Destructor Documentation

Isolate() [1/2]

v8::Isolate::Isolate ( )

private

Isolate() [2/2]

v8::Isolate::Isolate ( const Isolate &  )

private

~Isolate()

v8::Isolate::~Isolate ( )

private

Member Function Documentation

AddCallCompletedCallback()

void v8::Isolate::AddCallCompletedCallback

(

CallCompletedCallback

callback

)

Adds a callback to notify the host application when a script finished running.

If a script re-enters the runtime during executing, the CallCompletedCallback is only invoked when the outer-most script execution ends. Executing scripts inside the callback do not trigger further callbacks.

Definition at line 6713 of file api.cc.

                                                                     {
  if (callback == NULL) return;
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->AddCallCompletedCallback(callback);
}

References v8::internal::Isolate::AddCallCompletedCallback(), and NULL.

Here is the call graph for this function:

AddGCEpilogueCallback()

void v8::Isolate::AddGCEpilogueCallback	(	GCEpilogueCallback	callback,
		GCType	gc_type_filter = kGCTypeAll
	)

Enables the host application to receive a notification after a garbage collection.

Allocations are allowed in the callback function, but the callback is not re-entrant: if the allocation inside it will trigger the garbage collection, the callback won't be called again. It is possible to specify the GCType filter for your callback. But it is not possible to register the same callback function two times with different GCType filters.

Definition at line 6465 of file api.cc.

                                                    {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->heap()->AddGCEpilogueCallback(callback, gc_type);
}

References v8::internal::Heap::AddGCEpilogueCallback(), and v8::internal::Isolate::heap().

Here is the call graph for this function:

AddGCPrologueCallback()

void v8::Isolate::AddGCPrologueCallback	(	GCPrologueCallback	callback,
		GCType	gc_type_filter = kGCTypeAll
	)

Enables the host application to receive a notification before a garbage collection.

Allocations are allowed in the callback function, but the callback is not re-entrant: if the allocation inside it will trigger the garbage collection, the callback won't be called again. It is possible to specify the GCType filter for your callback. But it is not possible to register the same callback function two times with different GCType filters.

Definition at line 6452 of file api.cc.

                                                    {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->heap()->AddGCPrologueCallback(callback, gc_type);
}

References v8::internal::Heap::AddGCPrologueCallback(), and v8::internal::Isolate::heap().

Here is the call graph for this function:

AdjustAmountOfExternalAllocatedMemory()

int64_t v8::Isolate::AdjustAmountOfExternalAllocatedMemory ( int64_t  change_in_bytes )

inline

Adjusts the amount of registered external memory.

Used to give V8 an indication of the amount of externally allocated memory that is kept alive by JavaScript objects. V8 uses this to decide when to perform global garbage collections. Registering externally allocated memory will trigger global garbage collections more often than it would otherwise in an attempt to garbage collect the JavaScript objects that keep the externally allocated memory alive.

Parameters

change_in_bytes

the change in externally allocated memory that is kept alive by JavaScript objects.

Returns

the adjusted value.

Definition at line 6890 of file v8.h.

                             {
  typedef internal::Internals I;
  int64_t* amount_of_external_allocated_memory =
      reinterpret_cast<int64_t*>(reinterpret_cast<uint8_t*>(this) +
                                 I::kAmountOfExternalAllocatedMemoryOffset);
  int64_t* amount_of_external_allocated_memory_at_last_global_gc =
      reinterpret_cast<int64_t*>(
          reinterpret_cast<uint8_t*>(this) +
          I::kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset);
  int64_t amount = *amount_of_external_allocated_memory + change_in_bytes;
  if (change_in_bytes > 0 &&
      amount - *amount_of_external_allocated_memory_at_last_global_gc >
          I::kExternalAllocationLimit) {
    CollectAllGarbage("external memory allocation limit reached.");
  } else {
    *amount_of_external_allocated_memory = amount;
  }
  return *amount_of_external_allocated_memory;
}

References I.

Referenced by v8::Shell::ReadBuffer(), and v8::ReadBufferWeakCallback().

Here is the caller graph for this function:

ClearInterrupt()

void v8::Isolate::ClearInterrupt

(

)

Clear interrupt request created by |RequestInterrupt|.

Can be called from another thread without acquiring a |Locker|.

Definition at line 6554 of file api.cc.

                             {
  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(this);
  i_isolate->stack_guard()->ClearApiInterrupt();
  i_isolate->set_api_interrupt_callback(NULL);
  i_isolate->set_api_interrupt_callback_data(NULL);
}

References NULL, and v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

CollectAllGarbage()

void v8::Isolate::CollectAllGarbage ( const char *  gc_reason )

private

Definition at line 6358 of file api.cc.

                                                     {
  reinterpret_cast<i::Isolate*>(this)->heap()->CollectAllGarbage(
      i::Heap::kNoGCFlags, gc_reason);
}

References v8::internal::Heap::kNoGCFlags.

ContextDisposedNotification()

int v8::Isolate::ContextDisposedNotification

(

)

Optional notification that a context has been disposed.

V8 uses these notifications to guide the GC heuristic. Returns the number of context disposals - including this one - since the last time V8 had a chance to clean up.

Definition at line 6807 of file api.cc.

                                           {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  return isolate->heap()->NotifyContextDisposed();
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::NotifyContextDisposed().

Referenced by v8::SourceGroup::ExecuteInThread(), and v8::Shell::RunMain().

Here is the call graph for this function:

Here is the caller graph for this function:

Dispose()

void v8::Isolate::Dispose

(

)

Disposes the isolate.

The isolate must not be entered by any thread to be disposable.

Definition at line 6609 of file api.cc.

                      {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  if (!Utils::ApiCheck(!isolate->IsInUse(),
                       "v8::Isolate::Dispose()",
                       "Disposing the isolate that is entered by a thread.")) {
    return;
  }
  isolate->TearDown();
}

References v8::Utils::ApiCheck(), v8::internal::Isolate::IsInUse(), and v8::internal::Isolate::TearDown().

Referenced by v8::SourceGroup::ExecuteInThread(), main(), v8::Shell::Main(), and v8::TestWithIsolate::TearDownTestCase().

Here is the call graph for this function:

Here is the caller graph for this function:

EnqueueMicrotask() [1/2]

void v8::Isolate::EnqueueMicrotask

(

Handle< Function >

microtask

)

Experimental: Enqueues the callback to the Microtask Work Queue.

Definition at line 6731 of file api.cc.

                                                         {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->EnqueueMicrotask(Utils::OpenHandle(*microtask));
}

References v8::internal::Isolate::EnqueueMicrotask(), and v8::Utils::OpenHandle().

Here is the call graph for this function:

EnqueueMicrotask() [2/2]

void v8::Isolate::EnqueueMicrotask	(	MicrotaskCallback	microtask,
		void *	data = NULL
	)

Experimental: Enqueues the callback to the Microtask Work Queue.

Definition at line 6737 of file api.cc.

                                                                      {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  i::HandleScope scope(isolate);
  i::Handle<i::CallHandlerInfo> callback_info =
      i::Handle<i::CallHandlerInfo>::cast(
          isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE));
  SET_FIELD_WRAPPED(callback_info, set_callback, microtask);
  SET_FIELD_WRAPPED(callback_info, set_data, data);
  isolate->EnqueueMicrotask(callback_info);
}

References v8::internal::CALL_HANDLER_INFO_TYPE, v8::internal::Handle< T >::cast(), v8::internal::Isolate::EnqueueMicrotask(), v8::internal::Isolate::factory(), and SET_FIELD_WRAPPED.

Here is the call graph for this function:

Enter()

void v8::Isolate::Enter

(

)

Methods below this point require holding a lock (using Locker) in a multi-threaded environment.

Sets this isolate as the entered one for the current thread. Saves the previously entered one (if any), so that it can be restored when exiting. Re-entering an isolate is allowed.

Definition at line 6620 of file api.cc.

                    {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->Enter();
}

References v8::internal::Isolate::Enter().

Referenced by v8::Isolate::Scope::Scope().

Here is the call graph for this function:

Here is the caller graph for this function:

Exit()

void v8::Isolate::Exit

(

)

Exits this isolate by restoring the previously entered one in the current thread.

The isolate may still stay the same, if it was entered more than once.

Requires: this == Isolate::GetCurrent().

Definition at line 6626 of file api.cc.

                   {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->Exit();
}

References v8::internal::Isolate::Exit().

Here is the call graph for this function:

GetCallingContext()

v8::Local< v8::Context > v8::Isolate::GetCallingContext

(

)

Returns the context of the calling JavaScript code.

That is the context of the top-most JavaScript frame. If there are no JavaScript frames an empty handle is returned.

Definition at line 6394 of file api.cc.

                                              {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  i::Handle<i::Object> calling = isolate->GetCallingNativeContext();
  if (calling.is_null()) return Local<Context>();
  return Utils::ToLocal(i::Handle<i::Context>::cast(calling));
}

References v8::internal::Isolate::GetCallingNativeContext(), v8::internal::Handle< T >::is_null(), and v8::Utils::ToLocal().

Here is the call graph for this function:

GetCodeRange()

void v8::Isolate::GetCodeRange	(	void **	start,
		size_t *	length_in_bytes
	)

Returns a memory range that can potentially contain jitted code.

On Win64, embedders are advised to install function table callbacks for these ranges, as default SEH won't be able to unwind through jitted code.

Might be empty on other platforms.

https://code.google.com/p/v8/issues/detail?id=3598

Definition at line 6829 of file api.cc.

                                                                  {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  if (isolate->code_range()->valid()) {
    *start = isolate->code_range()->start();
    *length_in_bytes = isolate->code_range()->size();
  } else {
    *start = NULL;
    *length_in_bytes = 0;
  }
}

References v8::internal::Isolate::code_range(), NULL, v8::internal::CodeRange::size(), v8::internal::CodeRange::start(), and v8::internal::CodeRange::valid().

Here is the call graph for this function:

GetCpuProfiler()

CpuProfiler * v8::Isolate::GetCpuProfiler

(

)

Returns CPU profiler for this isolate.

Will return NULL unless the isolate is initialized. It is the embedder's responsibility to stop all CPU profiling activities if it has started any.

Definition at line 6371 of file api.cc.

                                     {
  i::CpuProfiler* cpu_profiler =
      reinterpret_cast<i::Isolate*>(this)->cpu_profiler();
  return reinterpret_cast<CpuProfiler*>(cpu_profiler);
}

GetCurrent()

Isolate * v8::Isolate::GetCurrent ( )

static

Returns the entered isolate for the current thread or NULL in case there is no current isolate.

Definition at line 6577 of file api.cc.

                             {
  i::Isolate* isolate = i::Isolate::Current();
  return reinterpret_cast<Isolate*>(isolate);
}

Referenced by v8::HandleDebugEvent().

Here is the caller graph for this function:

GetCurrentContext()

v8::Local< v8::Context > v8::Isolate::GetCurrentContext

(

)

Returns the context that is on the top of the stack.

Definition at line 6384 of file api.cc.

                                              {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  i::Context* context = isolate->context();
  if (context == NULL) return Local<Context>();
  i::Context* native_context = context->native_context();
  if (native_context == NULL) return Local<Context>();
  return Utils::ToLocal(i::Handle<i::Context>(native_context));
}

References v8::internal::Isolate::context(), v8::internal::Context::native_context(), NULL, and v8::Utils::ToLocal().

Here is the call graph for this function:

GetData()

void * v8::Isolate::GetData ( uint32_t  slot )

inline

Retrieve embedder-specific data from the isolate.

Returns NULL if SetData has never been called for the given |slot|.

Definition at line 6878 of file v8.h.

                                    {
  typedef internal::Internals I;
  return I::GetEmbedderData(this, slot);
}

References I.

Referenced by v8::PerIsolateData::Get().

Here is the caller graph for this function:

GetEnteredContext()

v8::Local< v8::Context > v8::Isolate::GetEnteredContext

(

)

Returns the last entered context.

Definition at line 6402 of file api.cc.

                                              {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  i::Handle<i::Object> last =
      isolate->handle_scope_implementer()->LastEnteredContext();
  if (last.is_null()) return Local<Context>();
  return Utils::ToLocal(i::Handle<i::Context>::cast(last));
}

References v8::internal::Isolate::handle_scope_implementer(), v8::internal::Handle< T >::is_null(), v8::internal::HandleScopeImplementer::LastEnteredContext(), and v8::Utils::ToLocal().

Referenced by v8::Shell::RealmCurrent(), and v8::PerIsolateData::RealmScope::RealmScope().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHeapProfiler()

HeapProfiler * v8::Isolate::GetHeapProfiler

(

)

Returns heap profiler for this isolate.

Will return NULL until the isolate is initialized.

Definition at line 6364 of file api.cc.

                                       {
  i::HeapProfiler* heap_profiler =
      reinterpret_cast<i::Isolate*>(this)->heap_profiler();
  return reinterpret_cast<HeapProfiler*>(heap_profiler);
}

GetHeapStatistics()

void v8::Isolate::GetHeapStatistics

(

HeapStatistics *

heap_statistics

)

Get statistics about the heap memory usage.

Definition at line 6685 of file api.cc.

                                                               {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  if (!isolate->IsInitialized()) {
    heap_statistics->total_heap_size_ = 0;
    heap_statistics->total_heap_size_executable_ = 0;
    heap_statistics->total_physical_size_ = 0;
    heap_statistics->used_heap_size_ = 0;
    heap_statistics->heap_size_limit_ = 0;
    return;
  }
  i::Heap* heap = isolate->heap();
  heap_statistics->total_heap_size_ = heap->CommittedMemory();
  heap_statistics->total_heap_size_executable_ =
      heap->CommittedMemoryExecutable();
  heap_statistics->total_physical_size_ = heap->CommittedPhysicalMemory();
  heap_statistics->used_heap_size_ = heap->SizeOfObjects();
  heap_statistics->heap_size_limit_ = heap->MaxReserved();
}

References v8::internal::Heap::CommittedMemory(), v8::internal::Heap::CommittedMemoryExecutable(), v8::internal::Heap::CommittedPhysicalMemory(), v8::internal::Isolate::heap(), v8::HeapStatistics::heap_size_limit_, v8::internal::Isolate::IsInitialized(), v8::internal::Heap::MaxReserved(), v8::internal::Heap::SizeOfObjects(), v8::HeapStatistics::total_heap_size_, v8::HeapStatistics::total_heap_size_executable_, v8::HeapStatistics::total_physical_size_, and v8::HeapStatistics::used_heap_size_.

Here is the call graph for this function:

GetNumberOfDataSlots()

uint32_t v8::Isolate::GetNumberOfDataSlots ( )

inlinestatic

Returns the maximum number of available embedder data slots.

Valid slots are in the range of 0 - GetNumberOfDataSlots() - 1.

Definition at line 6884 of file v8.h.

                                       {
  typedef internal::Internals I;
  return I::kNumIsolateDataSlots;
}

References I.

IdleNotification()

bool v8::Isolate::IdleNotification

(

int

idle_time_in_ms

)

Optional notification that the embedder is idle.

V8 uses the notification to reduce memory footprint. This call can be used repeatedly if the embedder remains idle. Returns true if the embedder should stop calling IdleNotification until real work has been done. This indicates that V8 has done as much cleanup as it will be able to do.

The idle_time_in_ms argument specifies the time V8 has to do reduce the memory footprint. There is no guarantee that the actual work will be done within the time limit.

Definition at line 6788 of file api.cc.

                                                    {
  // Returning true tells the caller that it need not
  // continue to call IdleNotification.
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  if (!i::FLAG_use_idle_notification) return true;
  return isolate->heap()->IdleNotification(idle_time_in_ms);
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::IdleNotification().

Referenced by v8::SourceGroup::ExecuteInThread(), and v8::Shell::RunMain().

Here is the call graph for this function:

Here is the caller graph for this function:

InContext()

bool v8::Isolate::InContext

(

)

Returns true if this isolate has a current context.

Definition at line 6378 of file api.cc.

                        {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  return isolate->context() != NULL;
}

References v8::internal::Isolate::context(), and NULL.

Referenced by v8::Shell::ReportException().

Here is the call graph for this function:

Here is the caller graph for this function:

LowMemoryNotification()

void v8::Isolate::LowMemoryNotification

(

)

Optional notification that the system is running low on memory.

V8 uses these notifications to attempt to free memory.

Definition at line 6797 of file api.cc.

                                      {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  {
    i::HistogramTimerScope idle_notification_scope(
        isolate->counters()->gc_low_memory_notification());
    isolate->heap()->CollectAllAvailableGarbage("low memory notification");
  }
}

References v8::internal::Heap::CollectAllAvailableGarbage(), v8::internal::Isolate::counters(), and v8::internal::Isolate::heap().

Referenced by v8::SourceGroup::ExecuteInThread(), and v8::Shell::RunMain().

Here is the call graph for this function:

Here is the caller graph for this function:

New()

Isolate * v8::Isolate::New ( const CreateParams &  params = CreateParams() )

static

Creates a new isolate.

Does not change the currently entered isolate.

When an isolate is no longer used its resources should be freed by calling Dispose(). Using the delete operator is not allowed.

V8::Initialize() must have run prior to this.

Definition at line 6583 of file api.cc.

                                                       {
  i::Isolate* isolate = new i::Isolate();
  Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
  if (params.entry_hook) {
    isolate->set_function_entry_hook(params.entry_hook);
  }
  if (params.code_event_handler) {
    isolate->InitializeLoggingAndCounters();
    isolate->logger()->SetCodeEventHandler(kJitCodeEventDefault,
                                           params.code_event_handler);
  }
  SetResourceConstraints(isolate, params.constraints);
  if (params.enable_serializer) {
    isolate->enable_serializer();
  }
  // TODO(jochen): Once we got rid of Isolate::Current(), we can remove this.
  Isolate::Scope isolate_scope(v8_isolate);
  if (params.entry_hook || !i::Snapshot::Initialize(isolate)) {
    // If the isolate has a function entry hook, it needs to re-build all its
    // code stubs with entry hooks embedded, so don't deserialize a snapshot.
    isolate->Init(NULL);
  }
  return v8_isolate;
}

References v8::Isolate::CreateParams::code_event_handler, v8::Isolate::CreateParams::constraints, v8::Isolate::CreateParams::enable_serializer, v8::internal::Isolate::enable_serializer(), v8::Isolate::CreateParams::entry_hook, v8::internal::Isolate::Init(), v8::internal::Snapshot::Initialize(), v8::internal::Isolate::InitializeLoggingAndCounters(), v8::kJitCodeEventDefault, v8::internal::Isolate::logger(), NULL, v8::internal::Isolate::set_function_entry_hook(), v8::internal::Logger::SetCodeEventHandler(), and v8::SetResourceConstraints().

Referenced by v8::SourceGroup::ExecuteInThread(), main(), v8::Shell::Main(), and v8::TestWithIsolate::SetUpTestCase().

Here is the call graph for this function:

Here is the caller graph for this function:

operator delete()

void v8::Isolate::operator delete ( void *  , size_t    )

private

operator new()

void* v8::Isolate::operator new ( size_t  size )

private

operator=()

Isolate& v8::Isolate::operator= ( const Isolate &  )

private

RemoveCallCompletedCallback()

void v8::Isolate::RemoveCallCompletedCallback

(

CallCompletedCallback

callback

)

Removes callback that was installed by AddCallCompletedCallback.

Definition at line 6720 of file api.cc.

                                                                        {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->RemoveCallCompletedCallback(callback);
}

References v8::internal::Isolate::RemoveCallCompletedCallback().

Here is the call graph for this function:

RemoveGCEpilogueCallback()

void v8::Isolate::RemoveGCEpilogueCallback

(

GCEpilogueCallback

callback

)

This function removes callback which was installed by AddGCEpilogueCallback function.

Definition at line 6472 of file api.cc.

                                                                  {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->heap()->RemoveGCEpilogueCallback(callback);
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::RemoveGCEpilogueCallback().

Here is the call graph for this function:

RemoveGCPrologueCallback()

void v8::Isolate::RemoveGCPrologueCallback

(

GCPrologueCallback

callback

)

This function removes callback which was installed by AddGCPrologueCallback function.

Definition at line 6459 of file api.cc.

                                                                  {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->heap()->RemoveGCPrologueCallback(callback);
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::RemoveGCPrologueCallback().

Here is the call graph for this function:

RequestGarbageCollectionForTesting()

void v8::Isolate::RequestGarbageCollectionForTesting

(

GarbageCollectionType

type

)

Request garbage collection in this Isolate.

It is only valid to call this function if –expose_gc was specified.

This should only be used for testing purposes and not to enforce a garbage collection schedule. It has strong negative impact on the garbage collection performance. Use IdleNotification() or LowMemoryNotification() instead to influence the garbage collection schedule.

Definition at line 6562 of file api.cc.

                                                                           {
  CHECK(i::FLAG_expose_gc);
  if (type == kMinorGarbageCollection) {
    reinterpret_cast<i::Isolate*>(this)->heap()->CollectGarbage(
        i::NEW_SPACE, "Isolate::RequestGarbageCollection",
        kGCCallbackFlagForced);
  } else {
    DCHECK_EQ(kFullGarbageCollection, type);
    reinterpret_cast<i::Isolate*>(this)->heap()->CollectAllGarbage(
        i::Heap::kAbortIncrementalMarkingMask,
        "Isolate::RequestGarbageCollection", kGCCallbackFlagForced);
  }
}

References CHECK, DCHECK_EQ, v8::internal::Heap::kAbortIncrementalMarkingMask, v8::kGCCallbackFlagForced, and v8::internal::NEW_SPACE.

Referenced by v8::internal::GCExtension::GC().

Here is the caller graph for this function:

RequestInterrupt()

void v8::Isolate::RequestInterrupt	(	InterruptCallback	callback,
		void *	data
	)

Request V8 to interrupt long running JavaScript code and invoke the given |callback| passing the given |data| to it.

After |callback| returns control will be returned to the JavaScript code. At any given moment V8 can remember only a single callback for the very last interrupt request. Can be called from another thread without acquiring a |Locker|. Registered |callback| must not reenter interrupted Isolate.

Definition at line 6546 of file api.cc.

                                                                     {
  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(this);
  i_isolate->set_api_interrupt_callback(callback);
  i_isolate->set_api_interrupt_callback_data(data);
  i_isolate->stack_guard()->RequestApiInterrupt();
}

References v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

RunMicrotasks()

void v8::Isolate::RunMicrotasks

(

)

Experimental: Runs the Microtask Work Queue until empty Any exceptions thrown by microtask callbacks are swallowed.

Definition at line 6726 of file api.cc.

                            {
  reinterpret_cast<i::Isolate*>(this)->RunMicrotasks();
}

SetAddHistogramSampleFunction()

void v8::Isolate::SetAddHistogramSampleFunction

(

AddHistogramSampleCallback

callback

)

Definition at line 6780 of file api.cc.

                                         {
  reinterpret_cast<i::Isolate*>(this)
      ->stats_table()
      ->SetAddHistogramSampleFunction(callback);
}

Referenced by v8::Shell::Initialize(), and v8::Shell::MapCounters().

Here is the caller graph for this function:

SetAutorunMicrotasks()

void v8::Isolate::SetAutorunMicrotasks

(

bool

autorun

)

Experimental: Controls whether the Microtask Work Queue is automatically run when the script call depth decrements to zero.

Definition at line 6749 of file api.cc.

                                               {
  reinterpret_cast<i::Isolate*>(this)->set_autorun_microtasks(autorun);
}

SetCounterFunction()

void v8::Isolate::SetCounterFunction

(

CounterLookupCallback

callback

)

Enables the host application to provide a mechanism for recording statistics counters.

Definition at line 6764 of file api.cc.

                                                               {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->stats_table()->SetCounterFunction(callback);
  isolate->InitializeLoggingAndCounters();
  isolate->counters()->ResetCounters();
}

References v8::internal::Isolate::counters(), v8::internal::Isolate::InitializeLoggingAndCounters(), v8::internal::Counters::ResetCounters(), v8::internal::StatsTable::SetCounterFunction(), and v8::internal::Isolate::stats_table().

Referenced by v8::Shell::Initialize(), and v8::Shell::MapCounters().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCreateHistogramFunction()

void v8::Isolate::SetCreateHistogramFunction

(

CreateHistogramCallback

callback

)

Enables the host application to provide a mechanism for recording histograms.

The CreateHistogram function returns a histogram which will later be passed to the AddHistogramSample function.

Definition at line 6772 of file api.cc.

                                                                         {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->stats_table()->SetCreateHistogramFunction(callback);
  isolate->InitializeLoggingAndCounters();
  isolate->counters()->ResetHistograms();
}

References v8::internal::Isolate::counters(), v8::internal::Isolate::InitializeLoggingAndCounters(), v8::internal::Counters::ResetHistograms(), v8::internal::StatsTable::SetCreateHistogramFunction(), and v8::internal::Isolate::stats_table().

Referenced by v8::Shell::Initialize(), and v8::Shell::MapCounters().

Here is the call graph for this function:

Here is the caller graph for this function:

SetData()

void v8::Isolate::SetData ( uint32_t  slot, void *  data  )

inline

Associate embedder-specific data with the isolate.

|slot| has to be between 0 and GetNumberOfDataSlots() - 1.

Definition at line 6872 of file v8.h.

                                               {
  typedef internal::Internals I;
  I::SetEmbedderData(this, slot, data);
}

References I.

Referenced by v8::PerIsolateData::PerIsolateData(), and v8::PerIsolateData::~PerIsolateData().

Here is the caller graph for this function:

SetEventLogger()

void v8::Isolate::SetEventLogger

(

LogEventCallback

that

)

Set the callback to invoke for logging event.

Definition at line 6705 of file api.cc.

                                                  {
  // Do not overwrite the event logger if we want to log explicitly.
  if (i::FLAG_log_timer_events) return;
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  isolate->set_event_logger(that);
}

SetJitCodeEventHandler()

void v8::Isolate::SetJitCodeEventHandler	(	JitCodeEventOptions	options,
		JitCodeEventHandler	event_handler
	)

Allows the host application to provide the address of a function that is notified each time code is added, moved or removed.

Parameters

options	options for the JIT code event handler.
event_handler	the JIT code event handler, which will be invoked each time code is added, moved or removed.

Note

event_handler won't get notified of existent code.

since code removal notifications are not currently issued, the event_handler may get notifications of code that overlaps earlier code notifications. This happens when code areas are reused, and the earlier overlapping code areas should therefore be discarded.

the events passed to event_handler and the strings they point to are not guaranteed to live past each call. The event_handler must copy strings and other parameters it needs to keep around.

the set of events declared in JitCodeEvent::EventType is expected to grow over time, and the JitCodeEvent structure is expected to accrue new members. The event_handler function must ignore event codes it does not recognize to maintain future compatibility.

Use Isolate::CreateParams to get events for code executed during Isolate setup.

Definition at line 6813 of file api.cc.

                                                                            {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  // Ensure that logging is initialized for our isolate.
  isolate->InitializeLoggingAndCounters();
  isolate->logger()->SetCodeEventHandler(options, event_handler);
}

References v8::internal::Isolate::InitializeLoggingAndCounters(), v8::internal::Isolate::logger(), and v8::internal::Logger::SetCodeEventHandler().

Here is the call graph for this function:

SetObjectGroupId() [1/2]

template<typename T >

void v8::Isolate::SetObjectGroupId	(	const Persistent< T > &	object,
		UniqueId	id
	)

Allows the host application to group objects together.

If one object in the group is alive, all objects in the group are alive. After each garbage collection, object groups are removed. It is intended to be used in the before-garbage-collection callback function, for instance to simulate DOM tree connections among JS wrapper objects. Object groups for all dependent handles need to be provided for kGCTypeMarkSweepCompact collections, for all other garbage collection types it is sufficient to provide object groups for partially dependent handles only.

Definition at line 6913 of file v8.h.

                                            {
  TYPE_CHECK(Value, T);
  SetObjectGroupId(reinterpret_cast<v8::internal::Object**>(object.val_), id);
}

References T, and TYPE_CHECK.

SetObjectGroupId() [2/2]

void v8::Isolate::SetObjectGroupId ( internal::Object **  object, UniqueId  id  )

private

Definition at line 6425 of file api.cc.

                                                                   {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(this);
  internal_isolate->global_handles()->SetObjectGroupId(
      v8::internal::Handle<v8::internal::Object>(object).location(),
      id);
}

References v8::internal::Isolate::global_handles(), and v8::internal::GlobalHandles::SetObjectGroupId().

Here is the call graph for this function:

SetReference() [1/2]

template<typename T , typename S >

void v8::Isolate::SetReference	(	const Persistent< T > &	parent,
		const Persistent< S > &	child
	)

Allows the host application to declare implicit references from an object to another object.

If the parent object is alive, the child object is alive too. After each garbage collection, all implicit references are removed. It is intended to be used in the before-garbage-collection callback function.

Definition at line 6930 of file v8.h.

                                                       {
  TYPE_CHECK(Object, T);
  TYPE_CHECK(Value, S);
  SetReference(reinterpret_cast<v8::internal::Object**>(parent.val_),
               reinterpret_cast<v8::internal::Object**>(child.val_));
}

References S, T, TYPE_CHECK, and v8::PersistentBase< T >::val_.

Referenced by v8::PersistentValueMap< K, V, Traits >::SetReference().

Here is the caller graph for this function:

SetReference() [2/2]

void v8::Isolate::SetReference ( internal::Object **  parent, internal::Object **  child  )

private

Definition at line 6441 of file api.cc.

                                                   {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(this);
  i::Object** parent_location =
      v8::internal::Handle<v8::internal::Object>(parent).location();
  internal_isolate->global_handles()->SetReference(
      reinterpret_cast<i::HeapObject**>(parent_location),
      v8::internal::Handle<v8::internal::Object>(child).location());
}

References v8::internal::Isolate::global_handles(), and v8::internal::GlobalHandles::SetReference().

Here is the call graph for this function:

SetReferenceFromGroup() [1/2]

template<typename T >

void v8::Isolate::SetReferenceFromGroup	(	UniqueId	id,
		const Persistent< T > &	child
	)

Allows the host application to declare implicit references from an object group to an object.

If the objects of the object group are alive, the child object is alive too. After each garbage collection, all implicit references are removed. It is intended to be used in the before-garbage-collection callback function.

Definition at line 6921 of file v8.h.

                                                                 {
  TYPE_CHECK(Value, T);
  SetReferenceFromGroup(id,
                        reinterpret_cast<v8::internal::Object**>(object.val_));
}

References T, and TYPE_CHECK.

SetReferenceFromGroup() [2/2]

void v8::Isolate::SetReferenceFromGroup ( UniqueId  id, internal::Object **  object  )

private

Definition at line 6433 of file api.cc.

                                                                        {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(this);
  internal_isolate->global_handles()->SetReferenceFromGroup(
      id,
      v8::internal::Handle<v8::internal::Object>(object).location());
}

References v8::internal::Isolate::global_handles(), and v8::internal::GlobalHandles::SetReferenceFromGroup().

Here is the call graph for this function:

SetStackLimit()

void v8::Isolate::SetStackLimit

(

uintptr_t

stack_limit

)

Modifies the stack limit for this Isolate.

Parameters

stack_limit

An address beyond which the Vm's stack may not grow.

Note

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.

Definition at line 6822 of file api.cc.

                                                   {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  CHECK(stack_limit);
  isolate->stack_guard()->SetStackLimit(stack_limit);
}

References CHECK, and v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

SetUseCounterCallback()

void v8::Isolate::SetUseCounterCallback

(

UseCounterCallback

callback

)

Sets a callback for counting the number of times a feature of V8 is used.

Definition at line 6759 of file api.cc.

                                                               {
  reinterpret_cast<i::Isolate*>(this)->SetUseCounterCallback(callback);
}

ThrowException()

v8::Local< Value > v8::Isolate::ThrowException

(

Local< Value >

exception

)

Schedules an exception to be thrown when returning to JavaScript.

When an exception has been scheduled it is illegal to invoke any JavaScript operation; the caller must return immediately and only after the exception has been handled does it become legal to invoke JavaScript operations.

Definition at line 6411 of file api.cc.

                                                             {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
  ENTER_V8(isolate);
  // If we're passed an empty handle, we throw an undefined exception
  // to deal more gracefully with out of memory situations.
  if (value.IsEmpty()) {
    isolate->ScheduleThrow(isolate->heap()->undefined_value());
  } else {
    isolate->ScheduleThrow(*Utils::OpenHandle(*value));
  }
  return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
}

References ENTER_V8, v8::internal::Isolate::heap(), v8::Handle< T >::IsEmpty(), v8::Utils::OpenHandle(), v8::internal::Isolate::ScheduleThrow(), and v8::Undefined().

Referenced by v8::Shell::ChangeDirectory(), v8::CheckItsADirectory(), v8::ChildLaunchedOK(), v8::internal::ExternalizeStringExtension::Externalize(), v8::GetStdout(), v8::GetTimeouts(), v8::ExecArgs::Init(), v8::internal::ExternalizeStringExtension::IsOneByte(), v8::Shell::MakeDirectory(), v8::mkdirp(), v8::Shell::RemoveDirectory(), v8::Shell::SetEnvironment(), v8::Shell::SetUMask(), v8::Shell::System(), v8::Throw(), v8::Shell::UnsetEnvironment(), and v8::WaitForChild().

Here is the call graph for this function:

Here is the caller graph for this function:

WillAutorunMicrotasks()

bool v8::Isolate::WillAutorunMicrotasks

(

)

const

Experimental: Returns whether the Microtask Work Queue is automatically run when the script call depth decrements to zero.

Definition at line 6754 of file api.cc.

                                          {
  return reinterpret_cast<const i::Isolate*>(this)->autorun_microtasks();
}

Friends And Related Function Documentation

PersistentValueMap

template<class K , class V , class Traits >

friend class PersistentValueMap

friend

Definition at line 4863 of file v8.h.

---

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

• /mnt/V8SourceCode/include/v8.h
• /mnt/V8SourceCode/src/api.cc