dart::SafepointHandler Class Reference

#include <safepoint.h>

Public Member Functions
	SafepointHandler (IsolateGroup *I)
	~SafepointHandler ()
void	EnterSafepointUsingLock (Thread *T)
void	ExitSafepointUsingLock (Thread *T)
void	BlockForSafepoint (Thread *T)
SafepointLevel	InnermostSafepointOperation (const Thread *current_thread) const
bool	AnySafepointInProgressLocked ()

Friends
class	Isolate
class	IsolateGroup
class	SafepointOperationScope
class	ForceGrowthSafepointOperationScope
class	HeapIterationScope

Detailed Description

Definition at line 81 of file safepoint.h.

Constructor & Destructor Documentation

SafepointHandler()

dart::SafepointHandler::SafepointHandler ( IsolateGroup *  I )

explicit

Definition at line 62 of file safepoint.cc.

    : isolate_group_(isolate_group) {
  handlers_[SafepointLevel::kGC] =
      new LevelHandler(isolate_group, SafepointLevel::kGC);
  handlers_[SafepointLevel::kGCAndDeopt] =
      new LevelHandler(isolate_group, SafepointLevel::kGCAndDeopt);
  handlers_[SafepointLevel::kGCAndDeoptAndReload] =
      new LevelHandler(isolate_group, SafepointLevel::kGCAndDeoptAndReload);
}

~SafepointHandler()

dart::SafepointHandler::~SafepointHandler

(

)

Definition at line 72 of file safepoint.cc.

                                    {
  for (intptr_t level = 0; level < SafepointLevel::kNumLevels; ++level) {
    ASSERT(handlers_[level]->owner_ == nullptr);
    delete handlers_[level];
  }
}

Member Function Documentation

AnySafepointInProgressLocked()

bool dart::SafepointHandler::AnySafepointInProgressLocked ( )

inline

Definition at line 108 of file safepoint.h.

                                      {
    for (intptr_t level = 0; level < SafepointLevel::kNumLevels; ++level) {
      if (handlers_[level]->SafepointInProgress()) {
        return true;
      }
    }
    return false;
  }

BlockForSafepoint()

void dart::SafepointHandler::BlockForSafepoint

(

Thread *

T

)

Definition at line 324 of file safepoint.cc.

                                                  {
  ASSERT(!T->BypassSafepoints());
  MonitorLocker tl(T->thread_lock());
  // This takes into account the safepoint level the thread can participate in.
  const SafepointLevel level = T->current_safepoint_level();
  if (T->IsSafepointRequestedLocked(level)) {
    EnterSafepointLocked(T, &tl, level);
    ExitSafepointLocked(T, &tl, level);
    ASSERT(!T->IsSafepointRequestedLocked(level));
  }
}

EnterSafepointUsingLock()

void dart::SafepointHandler::EnterSafepointUsingLock

(

Thread *

T

)

Definition at line 279 of file safepoint.cc.

                                                        {
  MonitorLocker tl(T->thread_lock());
  EnterSafepointLocked(T, &tl, T->current_safepoint_level());
}

ExitSafepointUsingLock()

void dart::SafepointHandler::ExitSafepointUsingLock

(

Thread *

T

)

Definition at line 284 of file safepoint.cc.

                                                       {
  MonitorLocker tl(T->thread_lock());
  ASSERT(T->IsAtSafepoint());
  ExitSafepointLocked(T, &tl, T->current_safepoint_level());
  ASSERT(!T->IsSafepointRequestedLocked(T->current_safepoint_level()));
}

InnermostSafepointOperation()

SafepointLevel dart::SafepointHandler::InnermostSafepointOperation

(

const Thread *

current_thread

)

const

Definition at line 291 of file safepoint.cc.

                                        {
  // The [current_thread] may not own the active safepoint.
  intptr_t last_count = -1;
  SafepointLevel last_level = SafepointLevel::kNoSafepoint;
 
  // Notice: We access SafepointLevel::{owner_,operation_count_} fields
  // without lock. This is ok since:
  //
  //   * If the current thread is the owner, then it will be the one that has
  //     last written `Thread::Current()` to the `owner_` field (as well as
  //     updated the `operation_count_`) - nobody else can update those fields
  //     in the meantime. Once the current thread exits we set it to `nullptr`.
  //
  //   * If there's no owner or another thread is the owner the value cannot be
  //     `Thread::Current()`: only our thread can write that particular value.
  //
  //   => Even if there's racy writes by another thread, the logic is still
  //      safe.
  //
  for (intptr_t level = 0; level < SafepointLevel::kNumLevels; ++level) {
    if (handlers_[level]->owner_ == current_thread) {
      const intptr_t count = handlers_[level]->operation_count_;
      if (count < last_count) return last_level;
      last_count = count;
      last_level = static_cast<SafepointLevel>(level);
    } else {
      return last_level;
    }
  }
  return last_level;
}

Friends And Related Function Documentation

ForceGrowthSafepointOperationScope

friend class ForceGrowthSafepointOperationScope

friend

Definition at line 208 of file safepoint.h.

HeapIterationScope

friend class HeapIterationScope

friend

Definition at line 209 of file safepoint.h.

Isolate

friend class Isolate

friend

Definition at line 205 of file safepoint.h.

IsolateGroup

friend class IsolateGroup

friend

Definition at line 206 of file safepoint.h.

SafepointOperationScope

friend class SafepointOperationScope

friend

Definition at line 207 of file safepoint.h.

---

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

• third_party/dart-lang/sdk/runtime/vm/heap/safepoint.h
• third_party/dart-lang/sdk/runtime/vm/heap/safepoint.cc