v8::internal::SamplerThread Class Reference

Inheritance diagram for v8::internal::SamplerThread:

Collaboration diagram for v8::internal::SamplerThread:

Public Member Functions
	SamplerThread (int interval)
virtual void	Run ()
Public Member Functions inherited from v8::base::Thread
	Thread (const Options &options)
virtual	~Thread ()
void	Start ()
void	StartSynchronously ()
void	Join ()
const char *	name () const
PlatformData *	data ()
void	NotifyStartedAndRun ()

Static Public Member Functions
static void	SetUp ()
static void	TearDown ()
static void	AddActiveSampler (Sampler *sampler)
static void	RemoveActiveSampler (Sampler *sampler)
Static Public Member Functions inherited from v8::base::Thread
static LocalStorageKey	CreateThreadLocalKey ()
static void	DeleteThreadLocalKey (LocalStorageKey key)
static void *	GetThreadLocal (LocalStorageKey key)
static int	GetThreadLocalInt (LocalStorageKey key)
static void	SetThreadLocal (LocalStorageKey key, void *value)
static void	SetThreadLocalInt (LocalStorageKey key, int value)
static bool	HasThreadLocal (LocalStorageKey key)
static void *	GetExistingThreadLocal (LocalStorageKey key)
static void	YieldCPU ()

Static Public Attributes
static const int	kSamplerThreadStackSize = 64 * KB
Static Public Attributes inherited from v8::base::Thread
static const int	kMaxThreadNameLength = 16

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (SamplerThread)

Private Attributes
const int	interval_
List< Sampler * >	active_samplers_

Static Private Attributes
static base::Mutex *	mutex_ = NULL
static SamplerThread *	instance_ = NULL

Additional Inherited Members
Public Types inherited from v8::base::Thread
typedef int32_t	LocalStorageKey

Detailed Description

Definition at line 489 of file sampler.cc.

Constructor & Destructor Documentation

SamplerThread()

v8::internal::SamplerThread::SamplerThread ( int  interval )

inlineexplicit

Definition at line 493 of file sampler.cc.

      : Thread(base::Thread::Options("SamplerThread", kSamplerThreadStackSize)),
        interval_(interval) {}

Referenced by AddActiveSampler().

Here is the caller graph for this function:

Member Function Documentation

AddActiveSampler()

static void v8::internal::SamplerThread::AddActiveSampler ( Sampler *  sampler )

inlinestatic

Definition at line 500 of file sampler.cc.

                                                 {
    bool need_to_start = false;
    base::LockGuard<base::Mutex> lock_guard(mutex_);
    if (instance_ == NULL) {
      // Start a thread that will send SIGPROF signal to VM threads,
      // when CPU profiling will be enabled.
      instance_ = new SamplerThread(sampler->interval());
      need_to_start = true;
    }
 
    DCHECK(sampler->IsActive());
    DCHECK(!instance_->active_samplers_.Contains(sampler));
    DCHECK(instance_->interval_ == sampler->interval());
    instance_->active_samplers_.Add(sampler);
 
    if (need_to_start) instance_->StartSynchronously();
  }

References active_samplers_, DCHECK, instance_, v8::internal::Sampler::interval(), interval_, v8::internal::Sampler::IsActive(), mutex_, NULL, SamplerThread(), and v8::base::Thread::StartSynchronously().

Referenced by v8::internal::Sampler::Start().

Here is the call graph for this function:

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

v8::internal::SamplerThread::DISALLOW_COPY_AND_ASSIGN ( SamplerThread  )

private

RemoveActiveSampler()

static void v8::internal::SamplerThread::RemoveActiveSampler ( Sampler *  sampler )

inlinestatic

Definition at line 518 of file sampler.cc.

                                                    {
    SamplerThread* instance_to_remove = NULL;
    {
      base::LockGuard<base::Mutex> lock_guard(mutex_);
 
      DCHECK(sampler->IsActive());
      bool removed = instance_->active_samplers_.RemoveElement(sampler);
      DCHECK(removed);
      USE(removed);
 
      // We cannot delete the instance immediately as we need to Join() the
      // thread but we are holding mutex_ and the thread may try to acquire it.
      if (instance_->active_samplers_.is_empty()) {
        instance_to_remove = instance_;
        instance_ = NULL;
      }
    }
 
    if (!instance_to_remove) return;
    instance_to_remove->Join();
    delete instance_to_remove;
  }

References active_samplers_, DCHECK, instance_, v8::internal::Sampler::IsActive(), v8::base::Thread::Join(), mutex_, NULL, and USE().

Referenced by v8::internal::Sampler::Stop().

Here is the call graph for this function:

Here is the caller graph for this function:

Run()

virtual void v8::internal::SamplerThread::Run ( )

inlinevirtual

Implements v8::base::Thread.

Definition at line 542 of file sampler.cc.

                     {
    while (true) {
      {
        base::LockGuard<base::Mutex> lock_guard(mutex_);
        if (active_samplers_.is_empty()) break;
        // When CPU profiling is enabled both JavaScript and C++ code is
        // profiled. We must not suspend.
        for (int i = 0; i < active_samplers_.length(); ++i) {
          Sampler* sampler = active_samplers_.at(i);
          if (!sampler->isolate()->IsInitialized()) continue;
          if (!sampler->IsProfiling()) continue;
          sampler->DoSample();
        }
      }
      base::OS::Sleep(interval_);
    }
  }

References active_samplers_, v8::internal::Sampler::DoSample(), interval_, v8::internal::Isolate::IsInitialized(), v8::internal::Sampler::isolate(), v8::internal::Sampler::IsProfiling(), mutex_, and v8::base::OS::Sleep().

Here is the call graph for this function:

SetUp()

static void v8::internal::SamplerThread::SetUp ( )

inlinestatic

Definition at line 497 of file sampler.cc.

{ if (!mutex_) mutex_ = new base::Mutex(); }

References mutex_.

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

Here is the caller graph for this function:

TearDown()

static void v8::internal::SamplerThread::TearDown ( )

inlinestatic

Definition at line 498 of file sampler.cc.

{ delete mutex_; mutex_ = NULL; }

References mutex_, and NULL.

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

Here is the caller graph for this function:

Member Data Documentation

active_samplers_

List<Sampler*> v8::internal::SamplerThread::active_samplers_

private

Definition at line 566 of file sampler.cc.

Referenced by AddActiveSampler(), RemoveActiveSampler(), and Run().

instance_

SamplerThread * v8::internal::SamplerThread::instance_ = NULL

staticprivate

Definition at line 563 of file sampler.cc.

Referenced by AddActiveSampler(), and RemoveActiveSampler().

interval_

const int v8::internal::SamplerThread::interval_

private

Definition at line 565 of file sampler.cc.

Referenced by AddActiveSampler(), and Run().

kSamplerThreadStackSize

const int v8::internal::SamplerThread::kSamplerThreadStackSize = 64 * KB

static

Definition at line 491 of file sampler.cc.

mutex_

base::Mutex * v8::internal::SamplerThread::mutex_ = NULL

staticprivate

Definition at line 562 of file sampler.cc.

Referenced by AddActiveSampler(), RemoveActiveSampler(), Run(), SetUp(), and TearDown().

---

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

• /mnt/V8SourceCode/src/sampler.cc