dart::MarkingVisitorBase< sync > Class Template Reference

Inheritance diagram for dart::MarkingVisitorBase< sync >:

Public Member Functions
	MarkingVisitorBase (IsolateGroup *isolate_group, PageSpace *page_space, MarkingStack *marking_stack, MarkingStack *new_marking_stack, MarkingStack *deferred_marking_stack)
	~MarkingVisitorBase ()
uintptr_t	marked_bytes () const
int64_t	marked_micros () const
void	AddMicros (int64_t micros)
void	set_concurrent (bool value)
bool	ProcessPendingWeakProperties ()
void	DrainMarkingStackWithPauseChecks ()
void	DrainMarkingStack ()
void	ProcessMarkingStackUntil (int64_t deadline)
bool	ProcessMarkingStack (intptr_t remaining_budget)
NO_SANITIZE_THREAD ObjectPtr	LoadPointerIgnoreRace (ObjectPtr *ptr)
NO_SANITIZE_THREAD CompressedObjectPtr	LoadCompressedPointerIgnoreRace (CompressedObjectPtr *ptr)
void	VisitPointers (ObjectPtr *first, ObjectPtr *last) override
intptr_t	ProcessWeakProperty (WeakPropertyPtr raw_weak)
intptr_t	ProcessWeakReference (WeakReferencePtr raw_weak)
intptr_t	ProcessWeakArray (WeakArrayPtr raw_weak)
intptr_t	ProcessFinalizerEntry (FinalizerEntryPtr raw_entry)
void	ProcessDeferredMarking ()
void	FinalizeMarking ()
void	MournWeakProperties ()
void	MournWeakReferences ()
void	MournWeakArrays ()
void	MournFinalizerEntries ()
bool	WaitForWork (RelaxedAtomic< uintptr_t > *num_busy)
void	Flush (GCLinkedLists *global_list)
void	Adopt (GCLinkedLists *other)
void	AbandonWork ()
void	FinalizeIncremental (GCLinkedLists *global_list)
GCLinkedLists *	delayed ()
Public Member Functions inherited from dart::ObjectPointerVisitor
	ObjectPointerVisitor (IsolateGroup *isolate_group)
virtual	~ObjectPointerVisitor ()
IsolateGroup *	isolate_group () const
virtual void	VisitTypedDataViewPointers (TypedDataViewPtr view, CompressedObjectPtr *first, CompressedObjectPtr *last)
void	VisitCompressedPointers (uword heap_base, CompressedObjectPtr *first, CompressedObjectPtr *last)
void	VisitPointers (ObjectPtr *p, intptr_t len)
void	VisitPointer (ObjectPtr *p)
const char *	gc_root_type () const
void	set_gc_root_type (const char *gc_root_type)
void	clear_gc_root_type ()
virtual bool	visit_weak_persistent_handles () const
virtual bool	trace_values_through_fields () const
const ClassTable *	class_table () const
virtual bool	CanVisitSuspendStatePointers (SuspendStatePtr suspend_state)

Static Public Member Functions
static bool	IsMarked (ObjectPtr raw)
static bool	ForwardOrSetNullIfCollected (ObjectPtr parent, CompressedObjectPtr *slot)

Detailed Description

template<bool sync>
class dart::MarkingVisitorBase< sync >

Definition at line 28 of file marker.cc.

Constructor & Destructor Documentation

MarkingVisitorBase()

template<bool sync>

dart::MarkingVisitorBase< sync >::MarkingVisitorBase ( IsolateGroup *  isolate_group, PageSpace *  page_space, MarkingStack *  marking_stack, MarkingStack *  new_marking_stack, MarkingStack *  deferred_marking_stack  )

inline

Definition at line 30 of file marker.cc.

      : ObjectPointerVisitor(isolate_group),
        page_space_(page_space),
        work_list_(marking_stack),
        new_work_list_(new_marking_stack),
        deferred_work_list_(deferred_marking_stack),
        marked_bytes_(0),
        marked_micros_(0),
        concurrent_(true) {}

~MarkingVisitorBase()

template<bool sync>

dart::MarkingVisitorBase< sync >::~MarkingVisitorBase ( )

inline

Definition at line 43 of file marker.cc.

{ ASSERT(delayed_.IsEmpty()); }

Member Function Documentation

AbandonWork()

template<bool sync>

void dart::MarkingVisitorBase< sync >::AbandonWork ( )

inline

Definition at line 450 of file marker.cc.

                     {
    work_list_.AbandonWork();
    new_work_list_.AbandonWork();
    deferred_work_list_.AbandonWork();
    delayed_.Release();
  }

AddMicros()

template<bool sync>

void dart::MarkingVisitorBase< sync >::AddMicros ( int64_t  micros )

inline

Definition at line 47 of file marker.cc.

{ marked_micros_ += micros; }

Adopt()

template<bool sync>

void dart::MarkingVisitorBase< sync >::Adopt ( GCLinkedLists *  other )

inline

Definition at line 445 of file marker.cc.

                                   {
    ASSERT(delayed_.IsEmpty());
    other->FlushInto(&delayed_);
  }

delayed()

template<bool sync>

GCLinkedLists * dart::MarkingVisitorBase< sync >::delayed ( )

inline

Definition at line 467 of file marker.cc.

{ return &delayed_; }

DrainMarkingStack()

template<bool sync>

void dart::MarkingVisitorBase< sync >::DrainMarkingStack ( )

inline

Definition at line 149 of file marker.cc.

                           {
    while (ProcessMarkingStack(kIntptrMax)) {
    }
  }

DrainMarkingStackWithPauseChecks()

template<bool sync>

void dart::MarkingVisitorBase< sync >::DrainMarkingStackWithPauseChecks ( )

inline

Definition at line 88 of file marker.cc.

                                          {
    do {
      ObjectPtr obj;
      while (work_list_.Pop(&obj)) {
        if (obj->IsNewObject()) {
          Page* page = Page::Of(obj);
          uword top = page->original_top();
          uword end = page->original_end();
          uword addr = static_cast<uword>(obj);
          if (top <= addr && addr < end) {
            new_work_list_.Push(obj);
            if (UNLIKELY(page_space_->pause_concurrent_marking())) {
              work_list_.Flush();
              new_work_list_.Flush();
              deferred_work_list_.Flush();
              page_space_->YieldConcurrentMarking();
            }
            continue;
          }
        }
 
        const intptr_t class_id = obj->GetClassId();
        ASSERT(class_id != kIllegalCid);
        ASSERT(class_id != kFreeListElement);
        ASSERT(class_id != kForwardingCorpse);
 
        intptr_t size;
        if (class_id == kWeakPropertyCid) {
          size = ProcessWeakProperty(static_cast<WeakPropertyPtr>(obj));
        } else if (class_id == kWeakReferenceCid) {
          size = ProcessWeakReference(static_cast<WeakReferencePtr>(obj));
        } else if (class_id == kWeakArrayCid) {
          size = ProcessWeakArray(static_cast<WeakArrayPtr>(obj));
        } else if (class_id == kFinalizerEntryCid) {
          size = ProcessFinalizerEntry(static_cast<FinalizerEntryPtr>(obj));
        } else if (sync && concurrent_ && class_id == kSuspendStateCid) {
          // Shape changing is not compatible with concurrent marking.
          deferred_work_list_.Push(obj);
          size = obj->untag()->HeapSize();
        } else {
          size = obj->untag()->VisitPointersNonvirtual(this);
        }
        if (!obj->IsNewObject()) {
          marked_bytes_ += size;
        }
 
        if (UNLIKELY(page_space_->pause_concurrent_marking())) {
          work_list_.Flush();
          new_work_list_.Flush();
          deferred_work_list_.Flush();
          page_space_->YieldConcurrentMarking();
        }
      }
    } while (ProcessPendingWeakProperties());
 
    ASSERT(work_list_.IsLocalEmpty());
    // In case of scavenge before final marking.
    new_work_list_.Flush();
    deferred_work_list_.Flush();
  }

FinalizeIncremental()

template<bool sync>

void dart::MarkingVisitorBase< sync >::FinalizeIncremental ( GCLinkedLists *  global_list )

inline

Definition at line 457 of file marker.cc.

                                                       {
    work_list_.Flush();
    work_list_.Finalize();
    new_work_list_.Flush();
    new_work_list_.Finalize();
    deferred_work_list_.Flush();
    deferred_work_list_.Finalize();
    delayed_.FlushInto(global_list);
  }

FinalizeMarking()

template<bool sync>

void dart::MarkingVisitorBase< sync >::FinalizeMarking ( )

inline

Definition at line 359 of file marker.cc.

                         {
    work_list_.Finalize();
    new_work_list_.Finalize();
    deferred_work_list_.Finalize();
    MournFinalizerEntries();
    // MournFinalizerEntries inserts newly discovered dead entries into the
    // linked list attached to the Finalizer. This might create
    // cross-generational references which might be added to the store
    // buffer. Release the store buffer to satisfy the invariant that
    // thread local store buffer is empty after marking and all references
    // are processed.
    Thread::Current()->ReleaseStoreBuffer();
  }

Flush()

template<bool sync>

void dart::MarkingVisitorBase< sync >::Flush ( GCLinkedLists *  global_list )

inline

Definition at line 438 of file marker.cc.

                                         {
    work_list_.Flush();
    new_work_list_.Flush();
    deferred_work_list_.Flush();
    delayed_.FlushInto(global_list);
  }

ForwardOrSetNullIfCollected()

template<bool sync>

static bool dart::MarkingVisitorBase< sync >::ForwardOrSetNullIfCollected ( ObjectPtr  parent, CompressedObjectPtr *  slot  )

inlinestatic

Definition at line 418 of file marker.cc.

                                                                     {
    ObjectPtr target = slot->Decompress(parent->heap_base());
    if (target->IsImmediateObject()) {
      // Object not touched during this GC.
      return false;
    }
    if (target->untag()->IsMarked()) {
      // Object already null (which is permanently marked) or has survived this
      // GC.
      return false;
    }
    *slot = Object::null();
    return true;
  }

IsMarked()

template<bool sync>

static bool dart::MarkingVisitorBase< sync >::IsMarked ( ObjectPtr  raw )

inlinestatic

Definition at line 54 of file marker.cc.

                                      {
    ASSERT(raw->IsHeapObject());
    return raw->untag()->IsMarked();
  }

LoadCompressedPointerIgnoreRace()

template<bool sync>

NO_SANITIZE_THREAD CompressedObjectPtr dart::MarkingVisitorBase< sync >::LoadCompressedPointerIgnoreRace ( CompressedObjectPtr *  ptr )

inline

Definition at line 251 of file marker.cc.

                                {
    return *ptr;
  }

LoadPointerIgnoreRace()

template<bool sync>

NO_SANITIZE_THREAD ObjectPtr dart::MarkingVisitorBase< sync >::LoadPointerIgnoreRace ( ObjectPtr *  ptr )

inline

Definition at line 249 of file marker.cc.

{ return *ptr; }

marked_bytes()

template<bool sync>

uintptr_t dart::MarkingVisitorBase< sync >::marked_bytes ( ) const

inline

Definition at line 45 of file marker.cc.

{ return marked_bytes_; }

marked_micros()

template<bool sync>

int64_t dart::MarkingVisitorBase< sync >::marked_micros ( ) const

inline

Definition at line 46 of file marker.cc.

{ return marked_micros_; }

MournFinalizerEntries()

template<bool sync>

void dart::MarkingVisitorBase< sync >::MournFinalizerEntries ( )

inline

Definition at line 407 of file marker.cc.

                               {
    FinalizerEntryPtr current = delayed_.finalizer_entries.Release();
    while (current != FinalizerEntry::null()) {
      FinalizerEntryPtr next = current->untag()->next_seen_by_gc();
      current->untag()->next_seen_by_gc_ = FinalizerEntry::null();
      MournFinalizerEntry(this, current);
      current = next;
    }
  }

MournWeakArrays()

template<bool sync>

void dart::MarkingVisitorBase< sync >::MournWeakArrays ( )

inline

Definition at line 394 of file marker.cc.

                         {
    WeakArrayPtr current = delayed_.weak_arrays.Release();
    while (current != WeakArray::null()) {
      WeakArrayPtr next = current->untag()->next_seen_by_gc();
      current->untag()->next_seen_by_gc_ = WeakArray::null();
      intptr_t length = Smi::Value(current->untag()->length());
      for (intptr_t i = 0; i < length; i++) {
        ForwardOrSetNullIfCollected(current, &current->untag()->data()[i]);
      }
      current = next;
    }
  }

MournWeakProperties()

template<bool sync>

void dart::MarkingVisitorBase< sync >::MournWeakProperties ( )

inline

Definition at line 373 of file marker.cc.

                             {
    WeakPropertyPtr current = delayed_.weak_properties.Release();
    while (current != WeakProperty::null()) {
      WeakPropertyPtr next = current->untag()->next_seen_by_gc();
      current->untag()->next_seen_by_gc_ = WeakProperty::null();
      current->untag()->key_ = Object::null();
      current->untag()->value_ = Object::null();
      current = next;
    }
  }

MournWeakReferences()

template<bool sync>

void dart::MarkingVisitorBase< sync >::MournWeakReferences ( )

inline

Definition at line 384 of file marker.cc.

                             {
    WeakReferencePtr current = delayed_.weak_references.Release();
    while (current != WeakReference::null()) {
      WeakReferencePtr next = current->untag()->next_seen_by_gc();
      current->untag()->next_seen_by_gc_ = WeakReference::null();
      ForwardOrSetNullIfCollected(current, &current->untag()->target_);
      current = next;
    }
  }

ProcessDeferredMarking()

template<bool sync>

void dart::MarkingVisitorBase< sync >::ProcessDeferredMarking ( )

inline

Definition at line 324 of file marker.cc.

                                {
    TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "ProcessDeferredMarking");
 
    ObjectPtr obj;
    while (deferred_work_list_.Pop(&obj)) {
      ASSERT(obj->IsHeapObject());
      // We need to scan objects even if they were already scanned via ordinary
      // marking. An object may have changed since its ordinary scan and been
      // added to deferred marking stack to compensate for write-barrier
      // elimination.
      // A given object may be included in the deferred marking stack multiple
      // times. It may or may not also be in the ordinary marking stack, so
      // failing to acquire the mark bit here doesn't reliably indicate the
      // object was already encountered through the deferred marking stack. Our
      // processing here is idempotent, so repeated visits only hurt performance
      // but not correctness. Duplication is expected to be low.
      // By the absence of a special case, we are treating WeakProperties as
      // strong references here. This guarantees a WeakProperty will only be
      // added to the delayed_weak_properties_ list of the worker that
      // encounters it during ordinary marking. This is in the same spirit as
      // the eliminated write barrier, which would have added the newly written
      // key and value to the ordinary marking stack.
      intptr_t size = obj->untag()->VisitPointersNonvirtual(this);
      // Add the size only if we win the marking race to prevent
      // double-counting.
      if (TryAcquireMarkBit(obj)) {
        if (!obj->IsNewObject()) {
          marked_bytes_ += size;
        }
      }
    }
  }

ProcessFinalizerEntry()

template<bool sync>

intptr_t dart::MarkingVisitorBase< sync >::ProcessFinalizerEntry ( FinalizerEntryPtr  raw_entry )

inline

Definition at line 313 of file marker.cc.

                                                              {
    ASSERT(IsMarked(raw_entry));
    delayed_.finalizer_entries.Enqueue(raw_entry);
    // Only visit token and next.
    MarkObject(LoadCompressedPointerIgnoreRace(&raw_entry->untag()->token_)
                   .Decompress(raw_entry->heap_base()));
    MarkObject(LoadCompressedPointerIgnoreRace(&raw_entry->untag()->next_)
                   .Decompress(raw_entry->heap_base()));
    return raw_entry->untag()->HeapSize();
  }

ProcessMarkingStack()

template<bool sync>

bool dart::MarkingVisitorBase< sync >::ProcessMarkingStack ( intptr_t  remaining_budget )

inline

Definition at line 172 of file marker.cc.

                                                      {
    do {
      // First drain the marking stacks.
      ObjectPtr obj;
      while (work_list_.Pop(&obj)) {
        if (sync && concurrent_ && obj->IsNewObject()) {
          Page* page = Page::Of(obj);
          uword top = page->original_top();
          uword end = page->original_end();
          uword addr = static_cast<uword>(obj);
          if (top <= addr && addr < end) {
            new_work_list_.Push(obj);
            // We did some work routing this object, but didn't look at any of
            // its slots.
            intptr_t size = kObjectAlignment;
            remaining_budget -= size;
            if (remaining_budget < 0) {
              return true;  // More to mark.
            }
            continue;
          }
        }
 
        const intptr_t class_id = obj->GetClassId();
        ASSERT(class_id != kIllegalCid);
        ASSERT(class_id != kFreeListElement);
        ASSERT(class_id != kForwardingCorpse);
 
        intptr_t size;
        if (class_id == kWeakPropertyCid) {
          size = ProcessWeakProperty(static_cast<WeakPropertyPtr>(obj));
        } else if (class_id == kWeakReferenceCid) {
          size = ProcessWeakReference(static_cast<WeakReferencePtr>(obj));
        } else if (class_id == kWeakArrayCid) {
          size = ProcessWeakArray(static_cast<WeakArrayPtr>(obj));
        } else if (class_id == kFinalizerEntryCid) {
          size = ProcessFinalizerEntry(static_cast<FinalizerEntryPtr>(obj));
        } else if (sync && concurrent_ && class_id == kSuspendStateCid) {
          // Shape changing is not compatible with concurrent marking.
          deferred_work_list_.Push(obj);
          size = obj->untag()->HeapSize();
        } else {
          if ((class_id == kArrayCid) || (class_id == kImmutableArrayCid)) {
            size = obj->untag()->HeapSize();
            if (size > remaining_budget) {
              work_list_.Push(obj);
              return true;  // More to mark.
            }
          }
          size = obj->untag()->VisitPointersNonvirtual(this);
        }
        if (!obj->IsNewObject()) {
          marked_bytes_ += size;
        }
        remaining_budget -= size;
        if (remaining_budget < 0) {
          return true;  // More to mark.
        }
      }
      // Marking stack is empty.
    } while (ProcessPendingWeakProperties());
 
    return false;  // No more work.
  }

ProcessMarkingStackUntil()

template<bool sync>

void dart::MarkingVisitorBase< sync >::ProcessMarkingStackUntil ( int64_t  deadline )

inline

Definition at line 154 of file marker.cc.

                                                  {
    // We check the clock *before* starting a batch of work, but we want to
    // *end* work before the deadline. So we compare to the deadline adjusted
    // by a conservative estimate of the duration of one batch of work.
    deadline -= 1500;
 
    // A 512kB budget is chosen to be large enough that we don't waste too much
    // time on the overhead of exiting ProcessMarkingStack, querying the clock,
    // and re-entering, and small enough that a few batches can fit in the idle
    // time between animation frames. This amount of marking takes ~1ms on a
    // Pixel phone.
    constexpr intptr_t kBudget = 512 * KB;
 
    while ((OS::GetCurrentMonotonicMicros() < deadline) &&
           ProcessMarkingStack(kBudget)) {
    }
  }

ProcessPendingWeakProperties()

template<bool sync>

bool dart::MarkingVisitorBase< sync >::ProcessPendingWeakProperties ( )

inline

Definition at line 59 of file marker.cc.

                                      {
    bool more_to_mark = false;
    WeakPropertyPtr cur_weak = delayed_.weak_properties.Release();
    while (cur_weak != WeakProperty::null()) {
      WeakPropertyPtr next_weak =
          cur_weak->untag()->next_seen_by_gc_.Decompress(cur_weak->heap_base());
      ObjectPtr raw_key = cur_weak->untag()->key();
      // Reset the next pointer in the weak property.
      cur_weak->untag()->next_seen_by_gc_ = WeakProperty::null();
      if (raw_key->IsImmediateObject() || raw_key->untag()->IsMarked()) {
        ObjectPtr raw_val = cur_weak->untag()->value();
        if (!raw_val->IsImmediateObject() && !raw_val->untag()->IsMarked()) {
          more_to_mark = true;
        }
 
        // The key is marked so we make sure to properly visit all pointers
        // originating from this weak property.
        cur_weak->untag()->VisitPointersNonvirtual(this);
      } else {
        // Requeue this weak property to be handled later.
        ASSERT(IsMarked(cur_weak));
        delayed_.weak_properties.Enqueue(cur_weak);
      }
      // Advance to next weak property in the queue.
      cur_weak = next_weak;
    }
    return more_to_mark;
  }

ProcessWeakArray()

template<bool sync>

intptr_t dart::MarkingVisitorBase< sync >::ProcessWeakArray ( WeakArrayPtr  raw_weak )

inline

Definition at line 308 of file marker.cc.

                                                   {
    delayed_.weak_arrays.Enqueue(raw_weak);
    return raw_weak->untag()->HeapSize();
  }

ProcessWeakProperty()

template<bool sync>

intptr_t dart::MarkingVisitorBase< sync >::ProcessWeakProperty ( WeakPropertyPtr  raw_weak )

inline

Definition at line 273 of file marker.cc.

                                                         {
    // The fate of the weak property is determined by its key.
    ObjectPtr raw_key =
        LoadCompressedPointerIgnoreRace(&raw_weak->untag()->key_)
            .Decompress(raw_weak->heap_base());
    if (raw_key->IsHeapObject() && !raw_key->untag()->IsMarked()) {
      // Key was white. Enqueue the weak property.
      ASSERT(IsMarked(raw_weak));
      delayed_.weak_properties.Enqueue(raw_weak);
      return raw_weak->untag()->HeapSize();
    }
    // Key is gray or black. Make the weak property black.
    return raw_weak->untag()->VisitPointersNonvirtual(this);
  }

ProcessWeakReference()

template<bool sync>

intptr_t dart::MarkingVisitorBase< sync >::ProcessWeakReference ( WeakReferencePtr  raw_weak )

inline

Definition at line 288 of file marker.cc.

                                                           {
    // The fate of the target field is determined by the target.
    // The type arguments always stay alive.
    ObjectPtr raw_target =
        LoadCompressedPointerIgnoreRace(&raw_weak->untag()->target_)
            .Decompress(raw_weak->heap_base());
    if (raw_target->IsHeapObject() && !raw_target->untag()->IsMarked()) {
      // Target was white. Enqueue the weak reference. It is potentially dead.
      // It might still be made alive by weak properties in next rounds.
      ASSERT(IsMarked(raw_weak));
      delayed_.weak_references.Enqueue(raw_weak);
    }
    // Always visit the type argument.
    ObjectPtr raw_type_arguments =
        LoadCompressedPointerIgnoreRace(&raw_weak->untag()->type_arguments_)
            .Decompress(raw_weak->heap_base());
    MarkObject(raw_type_arguments);
    return raw_weak->untag()->HeapSize();
  }

set_concurrent()

template<bool sync>

void dart::MarkingVisitorBase< sync >::set_concurrent ( bool  value )

inline

Definition at line 48 of file marker.cc.

{ concurrent_ = value; }

VisitPointers()

template<bool sync>

void dart::MarkingVisitorBase< sync >::VisitPointers ( ObjectPtr *  first, ObjectPtr *  last  )

inlineoverridevirtual

Implements dart::ObjectPointerVisitor.

Definition at line 256 of file marker.cc.

                                                                 {
    for (ObjectPtr* current = first; current <= last; current++) {
      MarkObject(LoadPointerIgnoreRace(current));
    }
  }

WaitForWork()

template<bool sync>

bool dart::MarkingVisitorBase< sync >::WaitForWork ( RelaxedAtomic< uintptr_t > *  num_busy )

inline

Definition at line 434 of file marker.cc.

                                                       {
    return work_list_.WaitForWork(num_busy);
  }

---

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

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