dart::EpilogueTask Class Reference

Inheritance diagram for dart::EpilogueTask:

Public Member Functions
	EpilogueTask (ThreadBarrier *barrier, IsolateGroup *isolate_group, PageSpace *old_space, FreeList *freelist, EpilogueState *state)
void	Run ()
void	RunEnteredIsolateGroup ()
void	Evacuate ()
void	ForwardStoreBuffer (IncrementalForwardingVisitor *visitor)
void	ForwardRememberedCards (IncrementalForwardingVisitor *visitor)
void	ForwardNewSpace (IncrementalForwardingVisitor *visitor)
DART_NOINLINE intptr_t	ForwardAndSweepNewPage (IncrementalForwardingVisitor *visitor, Page *page)
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 630 of file incremental_compactor.cc.

Constructor & Destructor Documentation

EpilogueTask()

dart::EpilogueTask::EpilogueTask ( ThreadBarrier *  barrier, IsolateGroup *  isolate_group, PageSpace *  old_space, FreeList *  freelist, EpilogueState *  state  )

inline

Definition at line 632 of file incremental_compactor.cc.

      : barrier_(barrier),
        isolate_group_(isolate_group),
        old_space_(old_space),
        freelist_(freelist),
        state_(state) {}

Member Function Documentation

Evacuate()

void dart::EpilogueTask::Evacuate ( )

inline

Definition at line 724 of file incremental_compactor.cc.

                  {
    TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "Evacuate");
 
    old_space_->AcquireLock(freelist_);
 
    bool any_failed = false;
    intptr_t bytes_evacuated = 0;
    Page* page;
    while (state_->NextEvacPage(&page)) {
      ASSERT(page->is_evacuation_candidate());
 
      bool page_failed = false;
      uword start = page->object_start();
      uword end = page->object_end();
      uword current = start;
      while (current < end) {
        ObjectPtr obj = UntaggedObject::FromAddr(current);
        intptr_t size = obj->untag()->HeapSize();
 
        if (obj->untag()->IsMarked()) {
          uword copied = old_space_->TryAllocatePromoLocked(freelist_, size);
          if (copied == 0) {
            obj->untag()->ClearIsEvacuationCandidateUnsynchronized();
            page_failed = true;
            any_failed = true;
          } else {
            ASSERT(!Page::Of(copied)->is_evacuation_candidate());
            bytes_evacuated += size;
            objcpy(reinterpret_cast<void*>(copied),
                   reinterpret_cast<const void*>(current), size);
            ObjectPtr copied_obj = UntaggedObject::FromAddr(copied);
 
            copied_obj->untag()->ClearIsEvacuationCandidateUnsynchronized();
            if (IsTypedDataClassId(copied_obj->GetClassId())) {
              static_cast<TypedDataPtr>(copied_obj)
                  ->untag()
                  ->RecomputeDataField();
            }
 
            ForwardingCorpse::AsForwarder(current, size)
                ->set_target(copied_obj);
          }
        }
 
        current += size;
      }
 
      if (page_failed) {
        page->set_evacuation_candidate(false);
      }
    }
 
    old_space_->ReleaseLock(freelist_);
    old_space_->usage_.used_in_words -= (bytes_evacuated >> kWordSizeLog2);
#if defined(SUPPORT_TIMELINE)
    tbes.SetNumArguments(1);
    tbes.FormatArgument(0, "bytes_evacuated", "%" Pd, bytes_evacuated);
#endif
 
    if (any_failed) {
      OS::PrintErr("evacuation failed\n");
    }
  }

ForwardAndSweepNewPage()

DART_NOINLINE intptr_t dart::EpilogueTask::ForwardAndSweepNewPage ( IncrementalForwardingVisitor *  visitor, Page *  page  )

inline

Definition at line 822 of file incremental_compactor.cc.

                                              {
    ASSERT(!page->is_image());
    ASSERT(!page->is_old());
    ASSERT(!page->is_executable());
 
    uword start = page->object_start();
    uword end = page->object_end();
    uword current = start;
    intptr_t free = 0;
    while (current < end) {
      ObjectPtr raw_obj = UntaggedObject::FromAddr(current);
      ASSERT(Page::Of(raw_obj) == page);
      uword tags = raw_obj->untag()->tags();
      intptr_t obj_size = raw_obj->untag()->HeapSize(tags);
      if (UntaggedObject::IsMarked(tags)) {
        raw_obj->untag()->ClearMarkBitUnsynchronized();
        ASSERT(IsAllocatableInNewSpace(obj_size));
        raw_obj->untag()->VisitPointers(visitor);
      } else {
        uword free_end = current + obj_size;
        while (free_end < end) {
          ObjectPtr next_obj = UntaggedObject::FromAddr(free_end);
          tags = next_obj->untag()->tags();
          if (UntaggedObject::IsMarked(tags)) {
            // Reached the end of the free block.
            break;
          }
          // Expand the free block by the size of this object.
          free_end += next_obj->untag()->HeapSize(tags);
        }
        obj_size = free_end - current;
#if defined(DEBUG)
        memset(reinterpret_cast<void*>(current), Heap::kZapByte, obj_size);
#endif  // DEBUG
        FreeListElement::AsElementNew(current, obj_size);
        free += obj_size;
      }
      current += obj_size;
    }
    return free;
  }

ForwardNewSpace()

void dart::EpilogueTask::ForwardNewSpace ( IncrementalForwardingVisitor *  visitor )

inline

Definition at line 812 of file incremental_compactor.cc.

                                                              {
    TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "ForwardNewSpace");
    Page* page;
    while (state_->NextNewPage(&page)) {
      intptr_t free = ForwardAndSweepNewPage(visitor, page);
      state_->AddNewFreeSize(free);
    }
  }

ForwardRememberedCards()

void dart::EpilogueTask::ForwardRememberedCards ( IncrementalForwardingVisitor *  visitor )

inline

Definition at line 804 of file incremental_compactor.cc.

                                                                     {
    TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "ForwardRememberedCards");
    for (Page* page = old_space_->large_pages_; page != nullptr;
         page = page->next()) {
      page->VisitRememberedCards(visitor, /*only_marked*/ true);
    }
  }

ForwardStoreBuffer()

void dart::EpilogueTask::ForwardStoreBuffer ( IncrementalForwardingVisitor *  visitor )

inline

Definition at line 788 of file incremental_compactor.cc.

                                                                 {
    TIMELINE_FUNCTION_GC_DURATION(Thread::Current(), "ForwardStoreBuffer");
 
    StoreBufferForwardingVisitor store_visitor(isolate_group_, visitor);
    StoreBuffer* store_buffer = isolate_group_->store_buffer();
    StoreBufferBlock* block;
    while (state_->NextBlock(&block)) {
      // Generated code appends to store buffers; tell MemorySanitizer.
      MSAN_UNPOISON(block, sizeof(*block));
 
      block->VisitObjectPointers(&store_visitor);
 
      store_buffer->PushBlock(block, StoreBuffer::kIgnoreThreshold);
    }
  }

Run()

void dart::EpilogueTask::Run ( )

inlinevirtual

Implements dart::ThreadPool::Task.

Definition at line 643 of file incremental_compactor.cc.

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

RunEnteredIsolateGroup()

void dart::EpilogueTask::RunEnteredIsolateGroup ( )

inline

Definition at line 657 of file incremental_compactor.cc.

                                {
    Thread* thread = Thread::Current();
 
    Evacuate();
 
    barrier_->Sync();
 
    IncrementalForwardingVisitor visitor(thread);
    if (state_->TakeOOM()) {
      old_space_->VisitRoots(&visitor);  // OOM reservation.
    }
    ForwardStoreBuffer(&visitor);
    ForwardRememberedCards(&visitor);
    ForwardNewSpace(&visitor);
    if (state_->TakeWeakHandles()) {
      TIMELINE_FUNCTION_GC_DURATION(thread, "WeakPersistentHandles");
      isolate_group_->VisitWeakPersistentHandles(&visitor);
    }
    if (state_->TakeWeakTables()) {
      TIMELINE_FUNCTION_GC_DURATION(thread, "WeakTables");
      isolate_group_->heap()->ForwardWeakTables(&visitor);
    }
#ifndef PRODUCT
    if (state_->TakeIdRing()) {
      TIMELINE_FUNCTION_GC_DURATION(thread, "IdRing");
      isolate_group_->ForEachIsolate(
          [&](Isolate* isolate) {
            ObjectIdRing* ring = isolate->object_id_ring();
            if (ring != nullptr) {
              ring->VisitPointers(&visitor);
            }
          },
          /*at_safepoint=*/true);
    }
#endif  // !PRODUCT
 
    barrier_->Sync();
 
    {
      // After forwarding the heap because visits each view's underyling buffer.
      TIMELINE_FUNCTION_GC_DURATION(thread, "Views");
      visitor.UpdateViews();
    }
 
    if (state_->TakeRoots()) {
      // After forwarding the heap because visiting the stack requires stackmaps
      // to already be forwarded.
      TIMELINE_FUNCTION_GC_DURATION(thread, "Roots");
      isolate_group_->VisitObjectPointers(
          &visitor, ValidationPolicy::kDontValidateFrames);
    }
 
    barrier_->Sync();
 
    {
      // After processing the object store because of the dependency on
      // canonicalized_stack_map_entries.
      TIMELINE_FUNCTION_GC_DURATION(thread, "SuspendStates");
      visitor.UpdateSuspendStates();
    }
 
    if (state_->TakeResetProgressBars()) {
      // After ForwardRememberedCards.
      old_space_->ResetProgressBars();
    }
  }

---

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

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