v8::internal::ThreadManager Class Reference

#include <v8threads.h>

Collaboration diagram for v8::internal::ThreadManager:

Public Member Functions
void	Lock ()
void	Unlock ()
void	ArchiveThread ()
bool	RestoreThread ()
void	FreeThreadResources ()
bool	IsArchived ()
void	Iterate (ObjectVisitor *v)
void	IterateArchivedThreads (ThreadVisitor *v)
bool	IsLockedByCurrentThread ()
ThreadId	CurrentId ()
void	TerminateExecution (ThreadId thread_id)
ThreadState *	FirstThreadStateInUse ()
ThreadState *	GetFreeThreadState ()

Private Member Functions
	ThreadManager ()
	~ThreadManager ()
void	DeleteThreadStateList (ThreadState *anchor)
void	EagerlyArchiveThread ()

Private Attributes
base::Mutex	mutex_
ThreadId	mutex_owner_
ThreadId	lazily_archived_thread_
ThreadState *	lazily_archived_thread_state_
ThreadState *	free_anchor_
ThreadState *	in_use_anchor_
Isolate *	isolate_

Friends
class	Isolate
class	ThreadState

Detailed Description

Definition at line 67 of file v8threads.h.

Constructor & Destructor Documentation

ThreadManager()

v8::internal::ThreadManager::ThreadManager ( )

private

Definition at line 245 of file v8threads.cc.

    : mutex_owner_(ThreadId::Invalid()),
      lazily_archived_thread_(ThreadId::Invalid()),
      lazily_archived_thread_state_(NULL),
      free_anchor_(NULL),
      in_use_anchor_(NULL) {
  free_anchor_ = new ThreadState(this);
  in_use_anchor_ = new ThreadState(this);
}

References free_anchor_, in_use_anchor_, and ThreadState.

~ThreadManager()

v8::internal::ThreadManager::~ThreadManager ( )

private

Definition at line 256 of file v8threads.cc.

                              {
  DeleteThreadStateList(free_anchor_);
  DeleteThreadStateList(in_use_anchor_);
}

References DeleteThreadStateList(), free_anchor_, and in_use_anchor_.

Here is the call graph for this function:

Member Function Documentation

ArchiveThread()

void v8::internal::ThreadManager::ArchiveThread

(

)

Definition at line 273 of file v8threads.cc.

                                  {
  DCHECK(lazily_archived_thread_.Equals(ThreadId::Invalid()));
  DCHECK(!IsArchived());
  DCHECK(IsLockedByCurrentThread());
  ThreadState* state = GetFreeThreadState();
  state->Unlink();
  Isolate::PerIsolateThreadData* per_thread =
      isolate_->FindOrAllocatePerThreadDataForThisThread();
  per_thread->set_thread_state(state);
  lazily_archived_thread_ = ThreadId::Current();
  lazily_archived_thread_state_ = state;
  DCHECK(state->id().Equals(ThreadId::Invalid()));
  state->set_id(CurrentId());
  DCHECK(!state->id().Equals(ThreadId::Invalid()));
}

References v8::internal::ThreadId::Current(), CurrentId(), DCHECK, v8::internal::Isolate::FindOrAllocatePerThreadDataForThisThread(), GetFreeThreadState(), v8::internal::ThreadState::id(), v8::internal::ThreadId::Invalid(), IsArchived(), IsLockedByCurrentThread(), isolate_, lazily_archived_thread_, lazily_archived_thread_state_, v8::internal::ThreadState::set_id(), and v8::internal::ThreadState::Unlink().

Referenced by v8::Unlocker::Initialize(), and v8::Locker::~Locker().

Here is the call graph for this function:

Here is the caller graph for this function:

CurrentId()

ThreadId v8::internal::ThreadManager::CurrentId

(

)

Definition at line 353 of file v8threads.cc.

                                  {
  return ThreadId::Current();
}

References v8::internal::ThreadId::Current().

Referenced by ArchiveThread().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteThreadStateList()

void v8::internal::ThreadManager::DeleteThreadStateList ( ThreadState *  anchor )

private

Definition at line 262 of file v8threads.cc.

                                                             {
  // The list starts and ends with the anchor.
  for (ThreadState* current = anchor->next_; current != anchor;) {
    ThreadState* next = current->next_;
    delete current;
    current = next;
  }
  delete anchor;
}

References v8::internal::ThreadState::next_.

Referenced by ~ThreadManager().

Here is the caller graph for this function:

EagerlyArchiveThread()

void v8::internal::ThreadManager::EagerlyArchiveThread ( )

private

Definition at line 290 of file v8threads.cc.

                                         {
  DCHECK(IsLockedByCurrentThread());
  ThreadState* state = lazily_archived_thread_state_;
  state->LinkInto(ThreadState::IN_USE_LIST);
  char* to = state->data();
  // Ensure that data containing GC roots are archived first, and handle them
  // in ThreadManager::Iterate(ObjectVisitor*).
  to = isolate_->handle_scope_implementer()->ArchiveThread(to);
  to = isolate_->ArchiveThread(to);
  to = Relocatable::ArchiveState(isolate_, to);
  to = isolate_->debug()->ArchiveDebug(to);
  to = isolate_->stack_guard()->ArchiveStackGuard(to);
  to = isolate_->regexp_stack()->ArchiveStack(to);
  to = isolate_->bootstrapper()->ArchiveState(to);
  lazily_archived_thread_ = ThreadId::Invalid();
  lazily_archived_thread_state_ = NULL;
}

References v8::internal::Debug::ArchiveDebug(), v8::internal::RegExpStack::ArchiveStack(), v8::internal::HandleScopeImplementer::ArchiveThread(), v8::internal::Isolate::ArchiveThread(), v8::internal::Isolate::bootstrapper(), v8::internal::ThreadState::data(), DCHECK, v8::internal::Isolate::debug(), v8::internal::Isolate::handle_scope_implementer(), v8::internal::ThreadState::IN_USE_LIST, v8::internal::ThreadId::Invalid(), IsLockedByCurrentThread(), isolate_, lazily_archived_thread_, lazily_archived_thread_state_, v8::internal::ThreadState::LinkInto(), NULL, v8::internal::Isolate::regexp_stack(), v8::internal::Isolate::stack_guard(), and to().

Referenced by RestoreThread().

Here is the call graph for this function:

Here is the caller graph for this function:

FirstThreadStateInUse()

ThreadState * v8::internal::ThreadManager::FirstThreadStateInUse

(

)

Definition at line 231 of file v8threads.cc.

                                                  {
  return in_use_anchor_->Next();
}

References in_use_anchor_, and v8::internal::ThreadState::Next().

Referenced by v8::internal::Deserializer::Deserialize(), Iterate(), IterateArchivedThreads(), v8::internal::StartupSerializer::SerializeStrongReferences(), and TerminateExecution().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeThreadResources()

void v8::internal::ThreadManager::FreeThreadResources

(

)

Definition at line 309 of file v8threads.cc.

                                        {
  DCHECK(!isolate_->has_pending_exception());
  DCHECK(!isolate_->external_caught_exception());
  DCHECK(isolate_->try_catch_handler() == NULL);
  isolate_->handle_scope_implementer()->FreeThreadResources();
  isolate_->FreeThreadResources();
  isolate_->debug()->FreeThreadResources();
  isolate_->stack_guard()->FreeThreadResources();
  isolate_->regexp_stack()->FreeThreadResources();
  isolate_->bootstrapper()->FreeThreadResources();
}

References v8::internal::Isolate::bootstrapper(), DCHECK, v8::internal::Isolate::debug(), v8::internal::HandleScopeImplementer::FreeThreadResources(), v8::internal::Debug::FreeThreadResources(), v8::internal::Isolate::FreeThreadResources(), v8::internal::RegExpStack::FreeThreadResources(), v8::internal::Isolate::handle_scope_implementer(), v8::internal::Isolate::has_pending_exception(), isolate_, NULL, v8::internal::Isolate::regexp_stack(), v8::internal::Isolate::stack_guard(), and v8::internal::Isolate::try_catch_handler().

Referenced by v8::Locker::~Locker().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFreeThreadState()

ThreadState * v8::internal::ThreadManager::GetFreeThreadState

(

)

Definition at line 219 of file v8threads.cc.

                                               {
  ThreadState* gotten = free_anchor_->next_;
  if (gotten == free_anchor_) {
    ThreadState* new_thread_state = new ThreadState(this);
    new_thread_state->AllocateSpace();
    return new_thread_state;
  }
  return gotten;
}

References v8::internal::ThreadState::AllocateSpace(), free_anchor_, v8::internal::ThreadState::next_, and ThreadState.

Referenced by ArchiveThread().

Here is the call graph for this function:

Here is the caller graph for this function:

IsArchived()

bool v8::internal::ThreadManager::IsArchived

(

)

Definition at line 322 of file v8threads.cc.

                               {
  Isolate::PerIsolateThreadData* data =
      isolate_->FindPerThreadDataForThisThread();
  return data != NULL && data->thread_state() != NULL;
}

References v8::internal::Isolate::FindPerThreadDataForThisThread(), isolate_, and NULL.

Referenced by ArchiveThread().

Here is the call graph for this function:

Here is the caller graph for this function:

IsLockedByCurrentThread()

bool v8::internal::ThreadManager::IsLockedByCurrentThread ( )

inline

Definition at line 79 of file v8threads.h.

                                 {
    return mutex_owner_.Equals(ThreadId::Current());
  }

References v8::internal::ThreadId::Current(), and mutex_owner_.

Referenced by ArchiveThread(), EagerlyArchiveThread(), v8::HandleScope::Initialize(), v8::Unlocker::Initialize(), v8::Locker::Initialize(), v8::Locker::IsLocked(), Lock(), RestoreThread(), v8::Locker::~Locker(), and v8::Unlocker::~Unlocker().

Here is the call graph for this function:

Here is the caller graph for this function:

Iterate()

void v8::internal::ThreadManager::Iterate

(

ObjectVisitor *

v

)

Definition at line 329 of file v8threads.cc.

                                            {
  // Expecting no threads during serialization/deserialization
  for (ThreadState* state = FirstThreadStateInUse();
       state != NULL;
       state = state->Next()) {
    char* data = state->data();
    data = HandleScopeImplementer::Iterate(v, data);
    data = isolate_->Iterate(v, data);
    data = Relocatable::Iterate(v, data);
  }
}

References FirstThreadStateInUse(), isolate_, v8::internal::Isolate::Iterate(), v8::internal::HandleScopeImplementer::Iterate(), and NULL.

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

Here is the call graph for this function:

Here is the caller graph for this function:

IterateArchivedThreads()

void v8::internal::ThreadManager::IterateArchivedThreads

(

ThreadVisitor *

v

)

Definition at line 342 of file v8threads.cc.

                                                           {
  for (ThreadState* state = FirstThreadStateInUse();
       state != NULL;
       state = state->Next()) {
    char* data = state->data();
    data += HandleScopeImplementer::ArchiveSpacePerThread();
    isolate_->IterateThread(v, data);
  }
}

References v8::internal::HandleScopeImplementer::ArchiveSpacePerThread(), FirstThreadStateInUse(), isolate_, v8::internal::Isolate::IterateThread(), and NULL.

Referenced by v8::internal::LiveEdit::CheckAndDropActivations(), v8::internal::Debug::PrepareForBreakPoints(), and v8::internal::MarkCompactCollector::PrepareForCodeFlushing().

Here is the call graph for this function:

Here is the caller graph for this function:

Lock()

void v8::internal::ThreadManager::Lock

(

)

Definition at line 158 of file v8threads.cc.

                         {
  mutex_.Lock();
  mutex_owner_ = ThreadId::Current();
  DCHECK(IsLockedByCurrentThread());
}

References v8::internal::ThreadId::Current(), DCHECK, IsLockedByCurrentThread(), mutex_, and mutex_owner_.

Referenced by v8::Locker::Initialize(), and v8::Unlocker::~Unlocker().

Here is the call graph for this function:

Here is the caller graph for this function:

RestoreThread()

bool v8::internal::ThreadManager::RestoreThread

(

)

Definition at line 103 of file v8threads.cc.

                                  {
  DCHECK(IsLockedByCurrentThread());
  // First check whether the current thread has been 'lazily archived', i.e.
  // not archived at all.  If that is the case we put the state storage we
  // had prepared back in the free list, since we didn't need it after all.
  if (lazily_archived_thread_.Equals(ThreadId::Current())) {
    lazily_archived_thread_ = ThreadId::Invalid();
    Isolate::PerIsolateThreadData* per_thread =
        isolate_->FindPerThreadDataForThisThread();
    DCHECK(per_thread != NULL);
    DCHECK(per_thread->thread_state() == lazily_archived_thread_state_);
    lazily_archived_thread_state_->set_id(ThreadId::Invalid());
    lazily_archived_thread_state_->LinkInto(ThreadState::FREE_LIST);
    lazily_archived_thread_state_ = NULL;
    per_thread->set_thread_state(NULL);
    return true;
  }
 
  // Make sure that the preemption thread cannot modify the thread state while
  // it is being archived or restored.
  ExecutionAccess access(isolate_);
 
  // If there is another thread that was lazily archived then we have to really
  // archive it now.
  if (lazily_archived_thread_.IsValid()) {
    EagerlyArchiveThread();
  }
  Isolate::PerIsolateThreadData* per_thread =
      isolate_->FindPerThreadDataForThisThread();
  if (per_thread == NULL || per_thread->thread_state() == NULL) {
    // This is a new thread.
    isolate_->stack_guard()->InitThread(access);
    return false;
  }
  ThreadState* state = per_thread->thread_state();
  char* from = state->data();
  from = isolate_->handle_scope_implementer()->RestoreThread(from);
  from = isolate_->RestoreThread(from);
  from = Relocatable::RestoreState(isolate_, from);
  from = isolate_->debug()->RestoreDebug(from);
  from = isolate_->stack_guard()->RestoreStackGuard(from);
  from = isolate_->regexp_stack()->RestoreStack(from);
  from = isolate_->bootstrapper()->RestoreState(from);
  per_thread->set_thread_state(NULL);
  if (state->terminate_on_restore()) {
    isolate_->stack_guard()->RequestTerminateExecution();
    state->set_terminate_on_restore(false);
  }
  state->set_id(ThreadId::Invalid());
  state->Unlink();
  state->LinkInto(ThreadState::FREE_LIST);
  return true;
}

References v8::internal::Isolate::bootstrapper(), v8::internal::ThreadId::Current(), v8::internal::ThreadState::data(), DCHECK, v8::internal::Isolate::debug(), EagerlyArchiveThread(), v8::internal::Isolate::FindPerThreadDataForThisThread(), v8::internal::ThreadState::FREE_LIST, v8::internal::Isolate::handle_scope_implementer(), v8::internal::ThreadId::Invalid(), IsLockedByCurrentThread(), isolate_, lazily_archived_thread_, lazily_archived_thread_state_, v8::internal::ThreadState::LinkInto(), NULL, v8::internal::Isolate::regexp_stack(), v8::internal::Debug::RestoreDebug(), v8::internal::RegExpStack::RestoreStack(), v8::internal::HandleScopeImplementer::RestoreThread(), v8::internal::Isolate::RestoreThread(), v8::internal::ThreadState::set_id(), v8::internal::ThreadState::set_terminate_on_restore(), v8::internal::Isolate::stack_guard(), v8::internal::ThreadState::terminate_on_restore(), and v8::internal::ThreadState::Unlink().

Referenced by v8::Locker::Initialize(), and v8::Unlocker::~Unlocker().

Here is the call graph for this function:

Here is the caller graph for this function:

TerminateExecution()

void v8::internal::ThreadManager::TerminateExecution

(

ThreadId

thread_id

)

Definition at line 358 of file v8threads.cc.

                                                         {
  for (ThreadState* state = FirstThreadStateInUse();
       state != NULL;
       state = state->Next()) {
    if (thread_id.Equals(state->id())) {
      state->set_terminate_on_restore(true);
    }
  }
}

References FirstThreadStateInUse(), and NULL.

Here is the call graph for this function:

Unlock()

void v8::internal::ThreadManager::Unlock

(

)

Definition at line 165 of file v8threads.cc.

                           {
  mutex_owner_ = ThreadId::Invalid();
  mutex_.Unlock();
}

References v8::internal::ThreadId::Invalid(), mutex_, and mutex_owner_.

Referenced by v8::Unlocker::Initialize(), and v8::Locker::~Locker().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

Isolate

friend class Isolate

friend

Definition at line 114 of file v8threads.h.

ThreadState

friend class ThreadState

friend

Definition at line 115 of file v8threads.h.

Referenced by GetFreeThreadState(), and ThreadManager().

Member Data Documentation

free_anchor_

ThreadState* v8::internal::ThreadManager::free_anchor_

private

Definition at line 108 of file v8threads.h.

Referenced by GetFreeThreadState(), v8::internal::ThreadState::LinkInto(), ThreadManager(), and ~ThreadManager().

in_use_anchor_

ThreadState* v8::internal::ThreadManager::in_use_anchor_

private

Definition at line 110 of file v8threads.h.

Referenced by FirstThreadStateInUse(), v8::internal::ThreadState::LinkInto(), v8::internal::ThreadState::Next(), ThreadManager(), and ~ThreadManager().

isolate_

Isolate* v8::internal::ThreadManager::isolate_

private

Definition at line 112 of file v8threads.h.

Referenced by ArchiveThread(), EagerlyArchiveThread(), FreeThreadResources(), IsArchived(), v8::internal::Isolate::Isolate(), Iterate(), IterateArchivedThreads(), and RestoreThread().

lazily_archived_thread_

ThreadId v8::internal::ThreadManager::lazily_archived_thread_

private

Definition at line 101 of file v8threads.h.

Referenced by ArchiveThread(), EagerlyArchiveThread(), and RestoreThread().

lazily_archived_thread_state_

ThreadState* v8::internal::ThreadManager::lazily_archived_thread_state_

private

Definition at line 102 of file v8threads.h.

Referenced by ArchiveThread(), EagerlyArchiveThread(), and RestoreThread().

mutex_

base::Mutex v8::internal::ThreadManager::mutex_

private

Definition at line 99 of file v8threads.h.

Referenced by Lock(), and Unlock().

mutex_owner_

ThreadId v8::internal::ThreadManager::mutex_owner_

private

Definition at line 100 of file v8threads.h.

Referenced by IsLockedByCurrentThread(), Lock(), and Unlock().

---

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

• /mnt/V8SourceCode/src/v8threads.h
• /mnt/V8SourceCode/src/v8threads.cc