dart::MarkingVisitorBase< sync > Class Template Reference

Inheritance diagram for dart::MarkingVisitorBase< sync >:

Public Member Functions
	MarkingVisitorBase (IsolateGroup *isolate_group, PageSpace *page_space, MarkingStack *old_marking_stack, MarkingStack *new_marking_stack, MarkingStack *tlab_deferred_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)
void	FinishedRoots ()
bool	ProcessPendingWeakProperties ()
DART_NOINLINE void	YieldConcurrentMarking ()
void	DrainMarkingStackWithPauseChecks ()
intptr_t	VisitCards (ArrayPtr obj)
void	DrainMarkingStack ()
void	ProcessOldMarkingStackUntil (int64_t deadline)
bool	ProcessOldMarkingStack (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)
virtual void	VisitPointers (ObjectPtr *first, ObjectPtr *last)=0
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 *  old_marking_stack, MarkingStack *  new_marking_stack, MarkingStack *  tlab_deferred_marking_stack, MarkingStack *  deferred_marking_stack  )

inline

Definition at line 30 of file marker.cc.

      : ObjectPointerVisitor(isolate_group),
        page_space_(page_space),
        old_work_list_(old_marking_stack),
        new_work_list_(new_marking_stack),
        tlab_deferred_work_list_(tlab_deferred_marking_stack),
        deferred_work_list_(deferred_marking_stack),
        marked_bytes_(0),
        marked_micros_(0),
        concurrent_(true),
        has_evacuation_candidate_(false) {}

~MarkingVisitorBase()

template<bool sync>

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

inline

Definition at line 46 of file marker.cc.

{ ASSERT(delayed_.IsEmpty()); }

Member Function Documentation

AbandonWork()

template<bool sync>

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

inline

Definition at line 605 of file marker.cc.

                     {
    old_work_list_.AbandonWork();
    new_work_list_.AbandonWork();
    tlab_deferred_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 50 of file marker.cc.

{ marked_micros_ += micros; }

Adopt()

template<bool sync>

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

inline

Definition at line 600 of file marker.cc.

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

delayed()

template<bool sync>

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

inline

Definition at line 625 of file marker.cc.

{ return &delayed_; }

DrainMarkingStack()

template<bool sync>

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

inline

Definition at line 234 of file marker.cc.

                           {
    ASSERT(!concurrent_);
    Thread* thread = Thread::Current();
    do {
      ObjectPtr obj;
      while (MarkerWorkList::Pop(&old_work_list_, &new_work_list_, &obj)) {
        ASSERT(!has_evacuation_candidate_);
 
        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 (obj->untag()->IsCardRemembered()) {
            ASSERT((class_id == kArrayCid) || (class_id == kImmutableArrayCid));
            size = VisitCards(static_cast<ArrayPtr>(obj));
          } else {
            size = obj->untag()->VisitPointersNonvirtual(this);
          }
        }
        if (has_evacuation_candidate_) {
          has_evacuation_candidate_ = false;
          if (!obj->untag()->IsCardRemembered() &&
              obj->untag()->TryAcquireRememberedBit()) {
            thread->StoreBufferAddObjectGC(obj);
          }
        }
        if (!obj->IsNewObject()) {
          marked_bytes_ += size;
        }
      }
    } while (ProcessPendingWeakProperties());
  }

DrainMarkingStackWithPauseChecks()

template<bool sync>

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

inline

Definition at line 117 of file marker.cc.

                                          {
    ASSERT(concurrent_);
    Thread* thread = Thread::Current();
    do {
      ObjectPtr obj;
      while (MarkerWorkList::Pop(&old_work_list_, &new_work_list_, &obj)) {
        ASSERT(!has_evacuation_candidate_);
 
        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-space objects still in a TLAB are deferred. This allows the
            // compiler to remove write barriers for freshly allocated objects.
            tlab_deferred_work_list_.Push(obj);
            if (UNLIKELY(page_space_->pause_concurrent_marking())) {
              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 (class_id == kSuspendStateCid) {
          // Shape changing is not compatible with concurrent marking.
          deferred_work_list_.Push(obj);
          size = obj->untag()->HeapSize();
        } else if (obj->untag()->IsCardRemembered()) {
          ASSERT((class_id == kArrayCid) || (class_id == kImmutableArrayCid));
          size = VisitCards(static_cast<ArrayPtr>(obj));
        } else {
          size = obj->untag()->VisitPointersNonvirtual(this);
        }
        if (has_evacuation_candidate_) {
          has_evacuation_candidate_ = false;
          if (!obj->untag()->IsCardRemembered()) {
            if (obj->untag()->TryAcquireRememberedBit()) {
              thread->StoreBufferAddObjectGC(obj);
            }
          }
        }
        if (!obj->IsNewObject()) {
          marked_bytes_ += size;
        }
 
        if (UNLIKELY(page_space_->pause_concurrent_marking())) {
          YieldConcurrentMarking();
        }
      }
    } while (ProcessPendingWeakProperties());
 
    ASSERT(old_work_list_.IsLocalEmpty());
    // In case of scavenge before final marking.
    new_work_list_.Flush();
    tlab_deferred_work_list_.Flush();
    deferred_work_list_.Flush();
  }

FinalizeIncremental()

template<bool sync>

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

inline

Definition at line 613 of file marker.cc.

                                                       {
    old_work_list_.Flush();
    old_work_list_.Finalize();
    new_work_list_.Flush();
    new_work_list_.Finalize();
    tlab_deferred_work_list_.Flush();
    tlab_deferred_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 503 of file marker.cc.

                         {
    old_work_list_.Finalize();
    new_work_list_.Finalize();
    tlab_deferred_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();
  }

FinishedRoots()

template<bool sync>

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

inline

Definition at line 62 of file marker.cc.

                       {
    // Nothing to remember for roots. Don't carry over to objects.
    has_evacuation_candidate_ = false;
  }

Flush()

template<bool sync>

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

inline

Definition at line 592 of file marker.cc.

                                         {
    old_work_list_.Flush();
    new_work_list_.Flush();
    tlab_deferred_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 563 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.
      if (target->untag()->IsEvacuationCandidate()) {
        if (parent->untag()->IsCardRemembered()) {
          Page::Of(parent)->RememberCard(slot);
        } else {
          if (parent->untag()->TryAcquireRememberedBit()) {
            Thread::Current()->StoreBufferAddObjectGC(parent);
          }
        }
      }
      return false;
    }
    *slot = Object::null();
    return true;
  }

IsMarked()

template<bool sync>

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

inlinestatic

Definition at line 57 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 370 of file marker.cc.

                                {
    return *ptr;
  }

LoadPointerIgnoreRace()

template<bool sync>

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

inline

Definition at line 368 of file marker.cc.

{ return *ptr; }

marked_bytes()

template<bool sync>

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

inline

Definition at line 48 of file marker.cc.

{ return marked_bytes_; }

marked_micros()

template<bool sync>

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

inline

Definition at line 49 of file marker.cc.

{ return marked_micros_; }

MournFinalizerEntries()

template<bool sync>

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

inline

Definition at line 552 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 539 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 518 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 529 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 459 of file marker.cc.

                                {
    Thread* thread = Thread::Current();
    TIMELINE_FUNCTION_GC_DURATION(thread, "ProcessDeferredMarking");
 
    ObjectPtr obj;
    while (deferred_work_list_.Pop(&obj)) {
      ASSERT(!has_evacuation_candidate_);
      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;
        }
      }
      if (has_evacuation_candidate_) {
        has_evacuation_candidate_ = false;
        if (!obj->untag()->IsCardRemembered() &&
            obj->untag()->TryAcquireRememberedBit()) {
          thread->StoreBufferAddObjectGC(obj);
        }
      }
    }
  }

ProcessFinalizerEntry()

template<bool sync>

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

inline

Definition at line 444 of file marker.cc.

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

ProcessOldMarkingStack()

template<bool sync>

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

inline

Definition at line 296 of file marker.cc.

                                                         {
    Thread* thread = Thread::Current();
    do {
      // First drain the marking stacks.
      ObjectPtr obj;
      while (old_work_list_.Pop(&obj)) {
        ASSERT(!has_evacuation_candidate_);
 
        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) {
              old_work_list_.Push(obj);
              return true;  // More to mark.
            }
          }
          if (obj->untag()->IsCardRemembered()) {
            ASSERT((class_id == kArrayCid) || (class_id == kImmutableArrayCid));
            size = VisitCards(static_cast<ArrayPtr>(obj));
          } else {
            size = obj->untag()->VisitPointersNonvirtual(this);
          }
        }
        if (has_evacuation_candidate_) {
          has_evacuation_candidate_ = false;
          if (!obj->untag()->IsCardRemembered() &&
              obj->untag()->TryAcquireRememberedBit()) {
            thread->StoreBufferAddObjectGC(obj);
          }
        }
        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.
  }

ProcessOldMarkingStackUntil()

template<bool sync>

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

inline

Definition at line 278 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) &&
           ProcessOldMarkingStack(kBudget)) {
    }
  }

ProcessPendingWeakProperties()

template<bool sync>

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

inline

Definition at line 67 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);
        if (has_evacuation_candidate_) {
          has_evacuation_candidate_ = false;
          if (!cur_weak->untag()->IsCardRemembered()) {
            if (cur_weak->untag()->TryAcquireRememberedBit()) {
              Thread::Current()->StoreBufferAddObjectGC(cur_weak);
            }
          }
        }
 
      } 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 439 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 396 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 411 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()) {
      if (!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);
      } else {
        if (raw_target->untag()->IsEvacuationCandidate()) {
          has_evacuation_candidate_ = true;
        }
      }
    }
    // Always visit the type argument.
    ObjectPtr raw_type_arguments =
        LoadCompressedPointerIgnoreRace(&raw_weak->untag()->type_arguments_)
            .Decompress(raw_weak->heap_base());
    if (MarkObject(raw_type_arguments)) {
      has_evacuation_candidate_ = true;
    }
    return raw_weak->untag()->HeapSize();
  }

set_concurrent()

template<bool sync>

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

inline

Definition at line 51 of file marker.cc.

{ concurrent_ = value; }

VisitCards()

template<bool sync>

intptr_t dart::MarkingVisitorBase< sync >::VisitCards ( ArrayPtr  obj )

inline

Definition at line 190 of file marker.cc.

                                    {
    ASSERT(obj->IsArray() || obj->IsImmutableArray());
    ASSERT(obj->untag()->IsCardRemembered());
    CompressedObjectPtr* obj_from = obj->untag()->from();
    CompressedObjectPtr* obj_to =
        obj->untag()->to(Smi::Value(obj->untag()->length()));
    uword heap_base = obj.heap_base();
 
    Page* page = Page::Of(obj);
    for (intptr_t i = 0, n = page->card_table_size(); i < n; i++) {
      CompressedObjectPtr* card_from =
          reinterpret_cast<CompressedObjectPtr*>(page) +
          (i << Page::kSlotsPerCardLog2);
      CompressedObjectPtr* card_to =
          reinterpret_cast<CompressedObjectPtr*>(card_from) +
          (1 << Page::kSlotsPerCardLog2) - 1;
      // Minus 1 because to is inclusive.
 
      if (card_from < obj_from) {
        // First card overlaps with header.
        card_from = obj_from;
      }
      if (card_to > obj_to) {
        // Last card(s) may extend past the object. Array truncation can make
        // this happen for more than one card.
        card_to = obj_to;
      }
 
      VisitCompressedPointers(heap_base, card_from, card_to);
      if (has_evacuation_candidate_) {
        has_evacuation_candidate_ = false;
        page->RememberCard(card_from);
      }
 
      if (((i + 1) % kCardsPerInterruptCheck) == 0) {
        if (UNLIKELY(page_space_->pause_concurrent_marking())) {
          YieldConcurrentMarking();
        }
      }
    }
 
    return obj->untag()->HeapSize();
  }

VisitPointers()

template<bool sync>

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

inlineoverridevirtual

Implements dart::ObjectPointerVisitor.

Definition at line 375 of file marker.cc.

                                                                 {
    bool has_evacuation_candidate = false;
    for (ObjectPtr* current = first; current <= last; current++) {
      has_evacuation_candidate |= MarkObject(LoadPointerIgnoreRace(current));
    }
    has_evacuation_candidate_ |= has_evacuation_candidate;
  }

WaitForWork()

template<bool sync>

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

inline

Definition at line 588 of file marker.cc.

                                                       {
    return old_work_list_.WaitForWork(num_busy);
  }

YieldConcurrentMarking()

template<bool sync>

DART_NOINLINE void dart::MarkingVisitorBase< sync >::YieldConcurrentMarking ( )

inline

Definition at line 106 of file marker.cc.

                                {
    old_work_list_.Flush();
    new_work_list_.Flush();
    tlab_deferred_work_list_.Flush();
    deferred_work_list_.Flush();
    Thread* thread = Thread::Current();
    thread->StoreBufferReleaseGC();
    page_space_->YieldConcurrentMarking();
    thread->StoreBufferAcquireGC();
  }

---

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

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