dart::GCMarker Class Reference

#include <marker.h>

Public Member Functions
	GCMarker (IsolateGroup *isolate_group, Heap *heap)
	~GCMarker ()
void	StartConcurrentMark (PageSpace *page_space)
void	IncrementalMarkWithUnlimitedBudget (PageSpace *page_space)
void	IncrementalMarkWithSizeBudget (PageSpace *page_space, intptr_t size)
void	IncrementalMarkWithTimeBudget (PageSpace *page_space, int64_t deadline)
void	MarkObjects (PageSpace *page_space)
intptr_t	marked_words () const
intptr_t	MarkedWordsPerMicro () const
void	PruneWeak (Scavenger *scavenger)

Friends
class	ConcurrentMarkTask
class	ParallelMarkTask
class	Scavenger
template<bool sync>
class	MarkingVisitorBase

Detailed Description

Definition at line 32 of file marker.h.

Constructor & Destructor Documentation

GCMarker()

dart::GCMarker::GCMarker	(	IsolateGroup *	isolate_group,
		Heap *	heap
	)

Definition at line 1088 of file marker.cc.

    : isolate_group_(isolate_group),
      heap_(heap),
      old_marking_stack_(),
      new_marking_stack_(),
      tlab_deferred_marking_stack_(),
      deferred_marking_stack_(),
      global_list_(),
      visitors_(),
      marked_bytes_(0),
      marked_micros_(0) {
  visitors_ = new SyncMarkingVisitor*[FLAG_marker_tasks];
  for (intptr_t i = 0; i < FLAG_marker_tasks; i++) {
    visitors_[i] = nullptr;
  }
}

~GCMarker()

dart::GCMarker::~GCMarker

(

)

Definition at line 1105 of file marker.cc.

                    {
  // Cleanup in case isolate shutdown happens after starting the concurrent
  // marker and before finalizing.
  if (isolate_group_->old_marking_stack() != nullptr) {
    isolate_group_->DisableIncrementalBarrier();
    for (intptr_t i = 0; i < FLAG_marker_tasks; i++) {
      visitors_[i]->AbandonWork();
      delete visitors_[i];
    }
  }
  delete[] visitors_;
}

Member Function Documentation

IncrementalMarkWithSizeBudget()

void dart::GCMarker::IncrementalMarkWithSizeBudget	(	PageSpace *	page_space,
		intptr_t	size
	)

Definition at line 1198 of file marker.cc.

                                                            {
  // Avoid setup overhead for tiny amounts of marking as the last bits of TLABs
  // get filled in.
  const intptr_t kMinimumMarkingStep = KB;
  if (size < kMinimumMarkingStep) return;
 
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(),
                                "IncrementalMarkWithSizeBudget");
 
  SyncMarkingVisitor visitor(isolate_group_, page_space, &old_marking_stack_,
                             &new_marking_stack_, &tlab_deferred_marking_stack_,
                             &deferred_marking_stack_);
  int64_t start = OS::GetCurrentMonotonicMicros();
  visitor.ProcessOldMarkingStack(size);
  int64_t stop = OS::GetCurrentMonotonicMicros();
  visitor.AddMicros(stop - start);
  {
    MonitorLocker ml(page_space->tasks_lock());
    visitor.FinalizeIncremental(&global_list_);
    marked_bytes_ += visitor.marked_bytes();
    marked_micros_ += visitor.marked_micros();
  }
}

IncrementalMarkWithTimeBudget()

void dart::GCMarker::IncrementalMarkWithTimeBudget	(	PageSpace *	page_space,
		int64_t	deadline
	)

Definition at line 1223 of file marker.cc.

                                                               {
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(),
                                "IncrementalMarkWithTimeBudget");
 
  SyncMarkingVisitor visitor(isolate_group_, page_space, &old_marking_stack_,
                             &new_marking_stack_, &tlab_deferred_marking_stack_,
                             &deferred_marking_stack_);
  int64_t start = OS::GetCurrentMonotonicMicros();
  visitor.ProcessOldMarkingStackUntil(deadline);
  int64_t stop = OS::GetCurrentMonotonicMicros();
  visitor.AddMicros(stop - start);
  {
    MonitorLocker ml(page_space->tasks_lock());
    visitor.FinalizeIncremental(&global_list_);
    marked_bytes_ += visitor.marked_bytes();
    marked_micros_ += visitor.marked_micros();
  }
}

IncrementalMarkWithUnlimitedBudget()

void dart::GCMarker::IncrementalMarkWithUnlimitedBudget

(

PageSpace *

page_space

)

Definition at line 1179 of file marker.cc.

                                                                       {
  TIMELINE_FUNCTION_GC_DURATION(Thread::Current(),
                                "IncrementalMarkWithUnlimitedBudget");
 
  SyncMarkingVisitor visitor(isolate_group_, page_space, &old_marking_stack_,
                             &new_marking_stack_, &tlab_deferred_marking_stack_,
                             &deferred_marking_stack_);
  int64_t start = OS::GetCurrentMonotonicMicros();
  visitor.ProcessOldMarkingStack(kIntptrMax);
  int64_t stop = OS::GetCurrentMonotonicMicros();
  visitor.AddMicros(stop - start);
  {
    MonitorLocker ml(page_space->tasks_lock());
    visitor.FinalizeIncremental(&global_list_);
    marked_bytes_ += visitor.marked_bytes();
    marked_micros_ += visitor.marked_micros();
  }
}

marked_words()

intptr_t dart::GCMarker::marked_words ( ) const

inline

Definition at line 51 of file marker.h.

{ return marked_bytes_ >> kWordSizeLog2; }

MarkedWordsPerMicro()

intptr_t dart::GCMarker::MarkedWordsPerMicro

(

)

const

Definition at line 1071 of file marker.cc.

                                             {
  intptr_t marked_words_per_job_micro;
  if (marked_micros_ == 0) {
    marked_words_per_job_micro = marked_words();  // Prevent division by zero.
  } else {
    marked_words_per_job_micro = marked_words() / marked_micros_;
  }
  if (marked_words_per_job_micro == 0) {
    marked_words_per_job_micro = 1;  // Prevent division by zero.
  }
  intptr_t jobs = FLAG_marker_tasks;
  if (jobs == 0) {
    jobs = 1;  // Marking on main thread is still one job.
  }
  return marked_words_per_job_micro * jobs;
}

MarkObjects()

void dart::GCMarker::MarkObjects

(

PageSpace *

page_space

)

Definition at line 1291 of file marker.cc.

                                                {
  if (isolate_group_->old_marking_stack() != nullptr) {
    isolate_group_->DisableIncrementalBarrier();
  }
 
  Prologue();
  {
    Thread* thread = Thread::Current();
    const int num_tasks = FLAG_marker_tasks;
    if (num_tasks == 0) {
      TIMELINE_FUNCTION_GC_DURATION(thread, "Mark");
      int64_t start = OS::GetCurrentMonotonicMicros();
      // Mark everything on main thread.
      UnsyncMarkingVisitor visitor(
          isolate_group_, page_space, &old_marking_stack_, &new_marking_stack_,
          &tlab_deferred_marking_stack_, &deferred_marking_stack_);
      visitor.set_concurrent(false);
      ResetSlices();
      IterateRoots(&visitor);
      visitor.FinishedRoots();
      visitor.ProcessDeferredMarking();
      visitor.DrainMarkingStack();
      visitor.ProcessDeferredMarking();
      visitor.FinalizeMarking();
      visitor.MournWeakProperties();
      visitor.MournWeakReferences();
      visitor.MournWeakArrays();
      visitor.MournFinalizerEntries();
      thread->ReleaseStoreBuffer();  // Ahead of IterateWeak
      IterateWeakRoots(thread);
      // All marking done; detach code, etc.
      int64_t stop = OS::GetCurrentMonotonicMicros();
      visitor.AddMicros(stop - start);
      marked_bytes_ += visitor.marked_bytes();
      marked_micros_ += visitor.marked_micros();
    } else {
      ThreadBarrier* barrier = new ThreadBarrier(num_tasks, 1);
 
      ResetSlices();
      // Used to coordinate draining among tasks; all start out as 'busy'.
      RelaxedAtomic<uintptr_t> num_busy = 0;
      // Phase 1: Iterate over roots and drain marking stack in tasks.
 
      for (intptr_t i = 0; i < num_tasks; ++i) {
        SyncMarkingVisitor* visitor = visitors_[i];
        // Visitors may or may not have already been created depending on
        // whether we did some concurrent marking.
        if (visitor == nullptr) {
          visitor = new SyncMarkingVisitor(
              isolate_group_, page_space, &old_marking_stack_,
              &new_marking_stack_, &tlab_deferred_marking_stack_,
              &deferred_marking_stack_);
          visitors_[i] = visitor;
        }
 
        // Move all work from local blocks to the global list. Any given
        // visitor might not get to run if it fails to reach TryEnter soon
        // enough, and we must fail to visit objects but they're sitting in
        // such a visitor's local blocks.
        visitor->Flush(&global_list_);
        // Need to move weak property list too.
 
        if (i < (num_tasks - 1)) {
          // Begin marking on a helper thread.
          bool result = Dart::thread_pool()->Run<ParallelMarkTask>(
              this, isolate_group_, &old_marking_stack_, barrier, visitor,
              &num_busy);
          ASSERT(result);
        } else {
          // Last worker is the main thread.
          visitor->Adopt(&global_list_);
          ParallelMarkTask task(this, isolate_group_, &old_marking_stack_,
                                barrier, visitor, &num_busy);
          task.RunEnteredIsolateGroup();
          barrier->Sync();
          barrier->Release();
        }
      }
 
      for (intptr_t i = 0; i < num_tasks; i++) {
        SyncMarkingVisitor* visitor = visitors_[i];
        visitor->FinalizeMarking();
        marked_bytes_ += visitor->marked_bytes();
        marked_micros_ += visitor->marked_micros();
        delete visitor;
        visitors_[i] = nullptr;
      }
 
      ASSERT(global_list_.IsEmpty());
    }
  }
 
  // Separate from verify_after_gc because that verification interferes with
  // concurrent marking.
  if (FLAG_verify_after_marking) {
    VerifyAfterMarkingVisitor visitor;
    heap_->VisitObjects(&visitor);
    if (visitor.failed()) {
      FATAL("verify after marking");
    }
  }
 
  Epilogue();
}

PruneWeak()

void dart::GCMarker::PruneWeak

(

Scavenger *

scavenger

)

Definition at line 1396 of file marker.cc.

                                             {
  scavenger->PruneWeak(&global_list_);
  for (intptr_t i = 0, n = FLAG_marker_tasks; i < n; i++) {
    scavenger->PruneWeak(visitors_[i]->delayed());
  }
}

StartConcurrentMark()

void dart::GCMarker::StartConcurrentMark

(

PageSpace *

page_space

)

Definition at line 1118 of file marker.cc.

                                                        {
  isolate_group_->EnableIncrementalBarrier(
      &old_marking_stack_, &new_marking_stack_, &deferred_marking_stack_);
 
  const intptr_t num_tasks = FLAG_marker_tasks;
 
  {
    // Bulk increase task count before starting any task, instead of
    // incrementing as each task is started, to prevent a task which
    // races ahead from falsely believing it was the last task to complete.
    MonitorLocker ml(page_space->tasks_lock());
    ASSERT(page_space->phase() == PageSpace::kDone);
    page_space->set_phase(PageSpace::kMarking);
    page_space->set_tasks(page_space->tasks() + num_tasks);
    page_space->set_concurrent_marker_tasks(
        page_space->concurrent_marker_tasks() + num_tasks);
    page_space->set_concurrent_marker_tasks_active(
        page_space->concurrent_marker_tasks_active() + num_tasks);
  }
 
  ResetSlices();
  for (intptr_t i = 0; i < num_tasks; i++) {
    ASSERT(visitors_[i] == nullptr);
    SyncMarkingVisitor* visitor = new SyncMarkingVisitor(
        isolate_group_, page_space, &old_marking_stack_, &new_marking_stack_,
        &tlab_deferred_marking_stack_, &deferred_marking_stack_);
    visitors_[i] = visitor;
 
    if (i < (num_tasks - 1)) {
      // Begin marking on a helper thread.
      bool result = Dart::thread_pool()->Run<ConcurrentMarkTask>(
          this, isolate_group_, page_space, visitor);
      ASSERT(result);
    } else {
      // For the last visitor, mark roots on the main thread.
      TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "ConcurrentMark");
      int64_t start = OS::GetCurrentMonotonicMicros();
      IterateRoots(visitor);
      visitor->FinishedRoots();
      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());
      }
      // Continue non-root marking concurrently.
      bool result = Dart::thread_pool()->Run<ConcurrentMarkTask>(
          this, isolate_group_, page_space, visitor);
      ASSERT(result);
    }
  }
 
  isolate_group_->DeferredMarkLiveTemporaries();
 
  // Wait for roots to be marked before exiting safepoint.
  MonitorLocker ml(&root_slices_monitor_);
  while (root_slices_finished_ != root_slices_count_) {
    ml.Wait();
  }
}

Friends And Related Function Documentation

ConcurrentMarkTask

friend class ConcurrentMarkTask

friend

Definition at line 100 of file marker.h.

MarkingVisitorBase

template<bool sync>

friend class MarkingVisitorBase

friend

Definition at line 104 of file marker.h.

ParallelMarkTask

friend class ParallelMarkTask

friend

Definition at line 101 of file marker.h.

Scavenger

friend class Scavenger

friend

Definition at line 102 of file marker.h.

---

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

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