dart::ParallelMarkTask Class Reference

Inheritance diagram for dart::ParallelMarkTask:

Public Member Functions
	ParallelMarkTask (GCMarker *marker, IsolateGroup *isolate_group, MarkingStack *marking_stack, ThreadBarrier *barrier, SyncMarkingVisitor *visitor, RelaxedAtomic< uintptr_t > *num_busy)
virtual void	Run ()
void	RunEnteredIsolateGroup ()
Public Member Functions inherited from dart::ThreadPool::Task
virtual	~Task ()
virtual void	Run ()=0
Public Member Functions inherited from dart::IntrusiveDListEntry< Task >
	IntrusiveDListEntry ()
	~IntrusiveDListEntry ()

Additional Inherited Members
Protected Member Functions inherited from dart::ThreadPool::Task
	Task ()

Detailed Description

Definition at line 890 of file marker.cc.

Constructor & Destructor Documentation

ParallelMarkTask()

dart::ParallelMarkTask::ParallelMarkTask ( GCMarker *  marker, IsolateGroup *  isolate_group, MarkingStack *  marking_stack, ThreadBarrier *  barrier, SyncMarkingVisitor *  visitor, RelaxedAtomic< uintptr_t > *  num_busy  )

inline

Definition at line 892 of file marker.cc.

      : marker_(marker),
        isolate_group_(isolate_group),
        marking_stack_(marking_stack),
        barrier_(barrier),
        visitor_(visitor),
        num_busy_(num_busy) {}

Member Function Documentation

Run()

virtual void dart::ParallelMarkTask::Run ( )

inlinevirtual

Implements dart::ThreadPool::Task.

Definition at line 905 of file marker.cc.

                     {
    if (!barrier_->TryEnter()) {
      barrier_->Release();
      return;
    }
 
    bool result = Thread::EnterIsolateGroupAsHelper(
        isolate_group_, Thread::kMarkerTask, /*bypass_safepoint=*/true);
    ASSERT(result);
 
    RunEnteredIsolateGroup();
 
    Thread::ExitIsolateGroupAsHelper(/*bypass_safepoint=*/true);
 
    barrier_->Sync();
    barrier_->Release();
  }

RunEnteredIsolateGroup()

void dart::ParallelMarkTask::RunEnteredIsolateGroup ( )

inline

Definition at line 923 of file marker.cc.

                                {
    {
      Thread* thread = Thread::Current();
      TIMELINE_FUNCTION_GC_DURATION(thread, "ParallelMark");
      int64_t start = OS::GetCurrentMonotonicMicros();
 
      // Phase 1: Iterate over roots and drain marking stack in tasks.
      num_busy_->fetch_add(1u);
      visitor_->set_concurrent(false);
      marker_->IterateRoots(visitor_);
      visitor_->FinishedRoots();
 
      visitor_->ProcessDeferredMarking();
 
      bool more_to_mark = false;
      do {
        do {
          visitor_->DrainMarkingStack();
        } while (visitor_->WaitForWork(num_busy_));
        // Wait for all markers to stop.
        barrier_->Sync();
#if defined(DEBUG)
        ASSERT(num_busy_->load() == 0);
        // Caveat: must not allow any marker to continue past the barrier
        // before we checked num_busy, otherwise one of them might rush
        // ahead and increment it.
        barrier_->Sync();
#endif
        // Check if we have any pending properties with marked keys.
        // Those might have been marked by another marker.
        more_to_mark = visitor_->ProcessPendingWeakProperties();
        if (more_to_mark) {
          // We have more work to do. Notify others.
          num_busy_->fetch_add(1u);
        }
 
        // Wait for all other markers to finish processing their pending
        // weak properties and decide if they need to continue marking.
        // Caveat: we need two barriers here to make this decision in lock step
        // between all markers and the main thread.
        barrier_->Sync();
        if (!more_to_mark && (num_busy_->load() > 0)) {
          // All markers continue to mark as long as any single marker has
          // some work to do.
          num_busy_->fetch_add(1u);
          more_to_mark = true;
        }
        barrier_->Sync();
      } while (more_to_mark);
 
      // Phase 2: deferred marking.
      visitor_->ProcessDeferredMarking();
      barrier_->Sync();
 
      // Phase 3: Weak processing and statistics.
      visitor_->MournWeakProperties();
      visitor_->MournWeakReferences();
      visitor_->MournWeakArrays();
      // Don't MournFinalizerEntries here, do it on main thread, so that we
      // don't have to coordinate workers.
 
      thread->ReleaseStoreBuffer();  // Ahead of IterateWeak
      barrier_->Sync();
      marker_->IterateWeakRoots(thread);
      int64_t stop = OS::GetCurrentMonotonicMicros();
      visitor_->AddMicros(stop - start);
      if (FLAG_log_marker_tasks) {
        THR_Print("Task marked %" Pd " bytes in %" Pd64 " micros.\n",
                  visitor_->marked_bytes(), visitor_->marked_micros());
      }
    }
  }

---

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

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