Inheritance diagram for dart::ScavengerVisitorBase< parallel >:

Public Member Functions
	ScavengerVisitorBase (IsolateGroup isolate_group, Scavenger scavenger, SemiSpace from, FreeList freelist, PromotionStack *promotion_stack)

	~ScavengerVisitorBase ()

void	VisitTypedDataViewPointers (TypedDataViewPtr view, CompressedObjectPtr first, CompressedObjectPtr last) override

void	VisitPointers (ObjectPtr first, ObjectPtr last) override

bool	PredicateVisitPointers (ObjectPtr first, ObjectPtr last) override

void	VisitingOldObject (ObjectPtr obj)

DART_FORCE_INLINE intptr_t	ProcessObject (ObjectPtr obj)

intptr_t	bytes_promoted () const

void	ProcessRoots ()

void	ProcessSurvivors ()

void	ProcessAll ()

void	ProcessWeakProperties ()

bool	HasWork ()

bool	WaitForWork (RelaxedAtomic< uintptr_t > *num_busy)

void	ProcessWeak ()

void	Finalize (StoreBuffer *store_buffer)

Page *	head () const

Page *	tail () const

void	set_pending (StoreBufferBlock *pending)

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)

Public Member Functions inherited from dart::PredicateObjectPointerVisitor
	PredicateObjectPointerVisitor ()

virtual	~PredicateObjectPointerVisitor ()

virtual bool	PredicateVisitPointers (ObjectPtr first, ObjectPtr last)=0

bool	PredicateVisitCompressedPointers (uword heap_base, CompressedObjectPtr first, CompressedObjectPtr last)

Static Public Member Functions
static bool	ForwardOrSetNullIfCollected (ObjectPtr parent, CompressedObjectPtr *ptr_address)

Detailed Description

template<bool parallel>
class dart::ScavengerVisitorBase< parallel >

Definition at line 130 of file scavenger.cc.

Constructor & Destructor Documentation

◆ ScavengerVisitorBase()

template<bool parallel>

dart::ScavengerVisitorBase< parallel >::ScavengerVisitorBase	(	IsolateGroup *	isolate_group,
		Scavenger *	scavenger,
		SemiSpace *	from,
		FreeList *	freelist,
		PromotionStack *	promotion_stack
	)

inlineexplicit

Definition at line 133 of file scavenger.cc.

      : ObjectPointerVisitor(isolate_group),
        thread_(nullptr),
        scavenger_(scavenger),
        from_(from),
        page_space_(scavenger->heap_->old_space()),
        freelist_(freelist),
        bytes_promoted_(0),
        visiting_old_object_(nullptr),
        pending_(nullptr),
        promoted_list_(promotion_stack) {}

◆ ~ScavengerVisitorBase()

template<bool parallel>

dart::ScavengerVisitorBase< parallel >::~ScavengerVisitorBase ( )

inline

Definition at line 148 of file scavenger.cc.

148{ ASSERT(pending_ == nullptr); }

ASSERT

#define ASSERT(E)

Definition: entrypoints_verification_test.cc:25

Member Function Documentation

◆ bytes_promoted()

template<bool parallel>

intptr_t dart::ScavengerVisitorBase< parallel >::bytes_promoted ( ) const

inline

Definition at line 277 of file scavenger.cc.

277{ return bytes_promoted_; }

◆ Finalize()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::Finalize ( StoreBuffer * store_buffer )

inline

Definition at line 358 of file scavenger.cc.

                                           {
    if (!scavenger_->abort_) {
      promoted_list_.Finalize();
      weak_array_list_.Finalize();
      weak_property_list_.Finalize();
      weak_reference_list_.Finalize();
      finalizer_entry_list_.Finalize();
      ASSERT(pending_ == nullptr);
    } else {
      promoted_list_.AbandonWork();
      weak_array_list_.AbandonWork();
      weak_property_list_.AbandonWork();
      weak_reference_list_.AbandonWork();
      finalizer_entry_list_.AbandonWork();
      if (pending_ != nullptr) {
        pending_->Reset();
        store_buffer->PushBlock(pending_, StoreBuffer::kIgnoreThreshold);
        pending_ = nullptr;
      }
    }
  }

◆ ForwardOrSetNullIfCollected()

template<bool parallel>

bool dart::ScavengerVisitorBase< parallel >::ForwardOrSetNullIfCollected	(	ObjectPtr	parent,
		CompressedObjectPtr *	ptr_address
	)

static

Definition at line 1740 of file scavenger.cc.

                               {
  ObjectPtr target = slot->Decompress(parent->heap_base());
  if (target->IsImmediateObject()) {
    // Object already null (which is old) or not touched during this GC.
    return false;
  }
  if (target->IsOldObject()) {
    if (parent->IsOldObject() && target->untag()->IsEvacuationCandidate()) {
      if (!parent->untag()->IsCardRemembered()) {
        if (parent->untag()->TryAcquireRememberedBit()) {
          Thread::Current()->StoreBufferAddObjectGC(parent);
        }
      }
    }
    return false;
  }
  uword header = ReadHeaderRelaxed(target);
  if (IsForwarding(header)) {
    // Get the new location of the object.
    target = ForwardedObj(header);
    *slot = target;
    if (target->IsNewObject() && parent->IsOldObject() &&
        parent->untag()->TryAcquireRememberedBit()) {
      Thread::Current()->StoreBufferAddObjectGC(parent);
    }
    return false;
  }
  ASSERT(target->IsHeapObject());
  ASSERT(target->IsNewObject());
  *slot = Object::null();
  return true;
}

◆ HasWork()

template<bool parallel>

bool dart::ScavengerVisitorBase< parallel >::HasWork ( )

inline

Definition at line 329 of file scavenger.cc.

                 {
    if (scavenger_->abort_) return false;
    return (scan_ != tail_) || (scan_ != nullptr && !scan_->IsResolved()) ||
           !promoted_list_.IsEmpty();
  }

◆ head()

template<bool parallel>

Page * dart::ScavengerVisitorBase< parallel >::head ( ) const

inline

Definition at line 380 of file scavenger.cc.

380{ return head_; }

◆ PredicateVisitPointers()

template<bool parallel>

bool dart::ScavengerVisitorBase< parallel >::PredicateVisitPointers	(	ObjectPtr *	first,
		ObjectPtr *	last
	)

inlineoverridevirtual

Implements dart::PredicateObjectPointerVisitor.

Definition at line 234 of file scavenger.cc.

                                                                          {
    bool has_new_target = false;
    for (ObjectPtr* current = first; current <= last; current++) {
      has_new_target |= PredicateScavengePointer(current);
    }
    return has_new_target;
  }

◆ ProcessAll()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::ProcessAll ( )

inline

Definition at line 304 of file scavenger.cc.

                    {
    TIMELINE_FUNCTION_GC_DURATION(thread_, "ProcessToSpace");
    LongJumpScope jump(thread_);
    if (setjmp(*jump.Set()) == 0) {
      do {
        do {
          ProcessToSpace();
          ProcessPromotedList();
        } while (HasWork());
        ProcessWeakPropertiesScoped();
      } while (HasWork());
    } else {
      ASSERT(scavenger_->abort_);
    }
  }

◆ ProcessObject()

template<bool parallel>

intptr_t dart::ScavengerVisitorBase< parallel >::ProcessObject ( ObjectPtr obj )

Definition at line 1407 of file scavenger.cc.

                                                                    {
#if defined(DEBUG)
  if (obj->IsNewObject()) {
    ASSERT(visiting_old_object_ == nullptr);
  } else {
    ASSERT(visiting_old_object_ == obj);
    ASSERT(!obj->untag()->IsRemembered());
  }
#endif
 
  intptr_t cid = obj->GetClassId();
  if (UNLIKELY(cid == kWeakPropertyCid)) {
    WeakPropertyPtr weak_property = static_cast<WeakPropertyPtr>(obj);
    if (!IsScavengeSurvivor(weak_property->untag()->key())) {
      weak_property_list_.Push(weak_property);
      return WeakProperty::InstanceSize();
    }
  } else if (UNLIKELY(cid == kWeakReferenceCid)) {
    WeakReferencePtr weak_reference = static_cast<WeakReferencePtr>(obj);
    if (!IsScavengeSurvivor(weak_reference->untag()->target())) {
#if !defined(DART_COMPRESSED_POINTERS)
      ScavengePointer(&weak_reference->untag()->type_arguments_);
#else
      ScavengeCompressedPointer(weak_reference->heap_base(),
                                &weak_reference->untag()->type_arguments_);
#endif
      weak_reference_list_.Push(weak_reference);
      return WeakReference::InstanceSize();
    }
  } else if (UNLIKELY(cid == kWeakArrayCid)) {
    WeakArrayPtr weak_array = static_cast<WeakArrayPtr>(obj);
    weak_array_list_.Push(weak_array);
    return WeakArray::InstanceSize(Smi::Value(weak_array->untag()->length()));
  } else if (UNLIKELY(cid == kFinalizerEntryCid)) {
    FinalizerEntryPtr finalizer_entry = static_cast<FinalizerEntryPtr>(obj);
#if !defined(DART_COMPRESSED_POINTERS)
    ScavengePointer(&finalizer_entry->untag()->token_);
    ScavengePointer(&finalizer_entry->untag()->next_);
#else
    ScavengeCompressedPointer(finalizer_entry->heap_base(),
                              &finalizer_entry->untag()->token_);
    ScavengeCompressedPointer(finalizer_entry->heap_base(),
                              &finalizer_entry->untag()->next_);
#endif
    finalizer_entry_list_.Push(finalizer_entry);
    return FinalizerEntry::InstanceSize();
  }
  return obj->untag()->VisitPointersNonvirtual(this);
}

◆ ProcessRoots()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::ProcessRoots ( )

inline

Definition at line 279 of file scavenger.cc.

                      {
    thread_ = Thread::Current();
    page_space_->AcquireLock(freelist_);
 
    LongJumpScope jump(thread_);
    if (setjmp(*jump.Set()) == 0) {
      scavenger_->IterateRoots(this);
    } else {
      ASSERT(scavenger_->abort_);
    }
  }

◆ ProcessSurvivors()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::ProcessSurvivors ( )

inline

Definition at line 291 of file scavenger.cc.

                          {
    LongJumpScope jump(thread_);
    if (setjmp(*jump.Set()) == 0) {
      // Iterate until all work has been drained.
      do {
        ProcessToSpace();
        ProcessPromotedList();
      } while (HasWork());
    } else {
      ASSERT(scavenger_->abort_);
    }
  }

◆ ProcessWeak()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::ProcessWeak ( )

inline

Definition at line 339 of file scavenger.cc.

                     {
    if (!scavenger_->abort_) {
      ASSERT(!HasWork());
 
      for (Page* page = head_; page != nullptr; page = page->next()) {
        ASSERT(page->IsResolved());
        page->RecordSurvivors();
      }
 
      MournWeakProperties();
      MournWeakReferences();
      MournWeakArrays();
      MournFinalizerEntries();
      scavenger_->IterateWeak();
    }
    page_space_->ReleaseLock(freelist_);
    thread_ = nullptr;
  }

◆ ProcessWeakProperties()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::ProcessWeakProperties ( )

inline

Definition at line 320 of file scavenger.cc.

                               {
    LongJumpScope jump(thread_);
    if (setjmp(*jump.Set()) == 0) {
      ProcessWeakPropertiesScoped();
    } else {
      ASSERT(scavenger_->abort_);
    }
  }

◆ set_pending()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::set_pending ( StoreBufferBlock * pending )

inline

Definition at line 382 of file scavenger.cc.

382{ pending_ = pending; }

◆ tail()

template<bool parallel>

Page * dart::ScavengerVisitorBase< parallel >::tail ( ) const

inline

Definition at line 381 of file scavenger.cc.

381{ return tail_; }

◆ VisitingOldObject()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::VisitingOldObject ( ObjectPtr obj )

inline

Definition at line 267 of file scavenger.cc.

                                        {
    ASSERT((obj == nullptr) || obj->IsOldObject());
    visiting_old_object_ = obj;
    if (obj != nullptr) {
      // Card update happens in Page::VisitRememberedCards.
      ASSERT(!obj->untag()->IsCardRemembered());
    }
  }

◆ VisitPointers()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::VisitPointers	(	ObjectPtr *	first,
		ObjectPtr *	last
	)

inlineoverridevirtual

Implements dart::ObjectPointerVisitor.

Definition at line 223 of file scavenger.cc.

                                                                 {
#if !defined(TARGET_ARCH_IA32)
    // Pointers embedded in Instructions are not aligned.
    ASSERT(Utils::IsAligned(first, sizeof(*first)));
    ASSERT(Utils::IsAligned(last, sizeof(*last)));
#endif
    for (ObjectPtr* current = first; current <= last; current++) {
      ScavengePointer(current);
    }
  }

◆ VisitTypedDataViewPointers()

template<bool parallel>

void dart::ScavengerVisitorBase< parallel >::VisitTypedDataViewPointers	(	TypedDataViewPtr	view,
		CompressedObjectPtr *	first,
		CompressedObjectPtr *	last
	)

inlineoverridevirtual

Reimplemented from dart::ObjectPointerVisitor.

Definition at line 154 of file scavenger.cc.

                                                                      {
    // TypedDataViews require extra processing to update their
    // PointerBase::data_ pointer. If the underlying typed data is external, no
    // update is needed. If the underlying typed data is internal, the pointer
    // must be updated if the typed data was copied or promoted. We cannot
    // safely dereference the underlying typed data to make this distinction.
    // It may have been forwarded by a different scavenger worker, so the access
    // could have a data race. Rather than checking the CID of the underlying
    // typed data, which requires dereferencing the copied/promoted header, we
    // compare the view's internal pointer to what it should be if the
    // underlying typed data was internal, and assume that external typed data
    // never points into the Dart heap. We must do this before VisitPointers
    // because we want to compare the old pointer and old typed data.
    const bool is_external =
        view->untag()->data_ != view->untag()->DataFieldForInternalTypedData();
 
    // Forward all fields of the typed data view.
    VisitCompressedPointers(view->heap_base(), first, last);
 
    if (view->untag()->data_ == nullptr) {
      ASSERT(RawSmiValue(view->untag()->offset_in_bytes()) == 0 &&
             RawSmiValue(view->untag()->length()) == 0);
      ASSERT(is_external);
      return;
    }
 
    // Explicit ifdefs because the compiler does not eliminate the unused
    // relaxed load.
#if defined(DEBUG)
    // Validate 'this' is a typed data view.
    const uword view_header = ReadHeaderRelaxed(view);
    ASSERT(!IsForwarding(view_header) || view->IsOldObject());
    ASSERT(IsTypedDataViewClassId(view->GetClassIdMayBeSmi()) ||
           IsUnmodifiableTypedDataViewClassId(view->GetClassIdMayBeSmi()));
 
    // Validate that the backing store is not a forwarding word. There is a data
    // race reader the backing store's header unless there is only one worker.
    TypedDataBasePtr td = view->untag()->typed_data();
    ASSERT(td->IsHeapObject());
    if (!parallel) {
      const uword td_header = ReadHeaderRelaxed(td);
      ASSERT(!IsForwarding(td_header) || td->IsOldObject());
      if (td != Object::null()) {
        // Fast object copy temporarily stores null in the typed_data field of
        // views. This can cause the RecomputeDataFieldForInternalTypedData to
        // run inappropriately, but when the object copy continues it will fix
        // the data_ pointer.
        ASSERT_EQUAL(IsExternalTypedDataClassId(td->GetClassId()), is_external);
      }
    }
#endif
 
    // If we have external typed data we can simply return since the backing
    // store lives in C-heap and will not move.
    if (is_external) {
      return;
    }
 
    // Now we update the inner pointer.
#if defined(DEBUG)
    if (!parallel) {
      ASSERT(IsTypedDataClassId(td->GetClassId()));
    }
#endif
    view->untag()->RecomputeDataFieldForInternalTypedData();
  }

◆ WaitForWork()

template<bool parallel>

bool dart::ScavengerVisitorBase< parallel >::WaitForWork ( RelaxedAtomic< uintptr_t > * num_busy )

inline

Definition at line 335 of file scavenger.cc.

                                                       {
    return promoted_list_.WaitForWork(num_busy, scavenger_->abort_);
  }

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

third_party/dart-lang/sdk/runtime/vm/heap/scavenger.cc

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ScavengerVisitorBase()

◆ ~ScavengerVisitorBase()

Member Function Documentation

◆ bytes_promoted()

◆ Finalize()

◆ ForwardOrSetNullIfCollected()

◆ HasWork()

◆ head()

◆ PredicateVisitPointers()

◆ ProcessAll()

◆ ProcessObject()

◆ ProcessRoots()

◆ ProcessSurvivors()

◆ ProcessWeak()

◆ ProcessWeakProperties()

◆ set_pending()

◆ tail()

◆ VisitingOldObject()

◆ VisitPointers()

◆ VisitTypedDataViewPointers()

◆ WaitForWork()