dart::CheckinTask Class Reference

Inheritance diagram for dart::CheckinTask:

Classes
struct	Data

Public Types
enum	State { kStartLoop = StateMachineTask::kNext }
Public Types inherited from dart::StateMachineTask
enum	State {   kInitialized = 0 , kEntered , kPleaseExit , kExited ,   kNext }

Public Member Functions
	CheckinTask (std::shared_ptr< Data > data)
Public Member Functions inherited from dart::StateMachineTask
	StateMachineTask (std::shared_ptr< Data > data)
virtual void	Run ()
Public Member Functions inherited from dart::ThreadPool::Task
virtual	~Task ()
virtual void	Run ()=0
Public Member Functions inherited from dart::IntrusiveDListEntry< Task >
	IntrusiveDListEntry ()
	~IntrusiveDListEntry ()

Protected Member Functions
Data *	data ()
virtual void	RunInternal ()
bool	SafepointIfRequested (Thread *thread, std::atomic< intptr_t > *checkins)
virtual void	RunInternal ()=0
Protected Member Functions inherited from dart::ThreadPool::Task
	Task ()

Additional Inherited Members
Protected Attributes inherited from dart::StateMachineTask
std::shared_ptr< Data >	data_
Thread *	thread_ = nullptr

Detailed Description

Definition at line 293 of file safepoint_test.cc.

Member Enumeration Documentation

State

enum dart::CheckinTask::State

Enumerator
kStartLoop

Definition at line 295 of file safepoint_test.cc.

             {
    kStartLoop = StateMachineTask::kNext,
  };

Constructor & Destructor Documentation

CheckinTask()

dart::CheckinTask::CheckinTask ( std::shared_ptr< Data >  data )

inlineexplicit

Definition at line 320 of file safepoint_test.cc.

: StateMachineTask(data) {}

Member Function Documentation

data()

Data * dart::CheckinTask::data ( )

inlineprotected

Definition at line 323 of file safepoint_test.cc.

{ return reinterpret_cast<Data*>(data_.get()); }

RunInternal()

virtual void dart::CheckinTask::RunInternal ( )

inlineprotectedvirtual

Implements dart::StateMachineTask.

Definition at line 325 of file safepoint_test.cc.

                             {
    data_->WaitUntil(kStartLoop);
 
    uword last_sync = OS::GetCurrentTimeMillis();
    while (!data()->IsIn(kPleaseExit)) {
      OS::SleepMicros(100);  // Make test avoid consuming 100% CPU x kTaskCount.
      switch (data()->level) {
        case SafepointLevel::kGC: {
          // This thread should join only GC safepoint operations.
          RuntimeCallDeoptScope no_deopt(
              Thread::Current(), RuntimeCallDeoptAbility::kCannotLazyDeopt);
          if (SafepointIfRequested(thread_, data()->gc_only_checkins)) {
            last_sync = OS::GetCurrentTimeMillis();
          }
          break;
        }
        case SafepointLevel::kGCAndDeopt: {
          // This thread should join only GC and Deopt safepoint operations.
          if (SafepointIfRequested(thread_, data()->deopt_checkin)) {
            last_sync = OS::GetCurrentTimeMillis();
          }
          break;
        }
        case SafepointLevel::kGCAndDeoptAndReload: {
          // This thread should join any safepoint operations.
          ReloadParticipationScope allow_reload(thread_);
          if (SafepointIfRequested(thread_, data()->reload_checkin)) {
            last_sync = OS::GetCurrentTimeMillis();
          }
          break;
        }
        case SafepointLevel::kNumLevels:
        case SafepointLevel::kNoSafepoint:
          UNREACHABLE();
      }
 
      // If the main thread asks us to join a deopt safepoint but we are
      // instructed to only really collaborate with GC safepoints we won't
      // participate in the above cases (and therefore not register our
      // check-in by increasing the checkin counts).
      //
      // After being quite sure to not have joined deopt safepoint if we only
      // support GC safepoints, we will eventually comply here to make main
      // thread continue.
      const auto now = OS::GetCurrentTimeMillis();
      if ((now - last_sync) > 1000) {
        ReloadParticipationScope allow_reload(thread_);
        if (SafepointIfRequested(thread_, data()->timeout_checkin)) {
          last_sync = now;
        }
      }
    }
  }

SafepointIfRequested()

bool dart::CheckinTask::SafepointIfRequested ( Thread *  thread, std::atomic< intptr_t > *  checkins  )

inlineprotected

Definition at line 379 of file safepoint_test.cc.

                                                                           {
    if (thread->IsSafepointRequested()) {
      // Collaborates by checking into the safepoint.
      thread->BlockForSafepoint();
      (*checkins)++;
      return true;
    }
    return false;
  }

---

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

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