dart::GCCompactor Class Reference

#include <compactor.h>

Inheritance diagram for dart::GCCompactor:

Public Member Functions
	GCCompactor (Thread *thread, Heap *heap)
	~GCCompactor ()
void	Compact (Page *pages, FreeList *freelist, Mutex *mutex)
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()
Public Member Functions inherited from dart::HandleVisitor
	HandleVisitor (Thread *thread)
virtual	~HandleVisitor ()
Thread *	thread () const
virtual void	VisitHandle (uword addr)=0
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)

Friends
class	CompactorTask

Detailed Description

Definition at line 23 of file compactor.h.

Constructor & Destructor Documentation

GCCompactor()

dart::GCCompactor::GCCompactor ( Thread *  thread, Heap *  heap  )

inline

Definition at line 27 of file compactor.h.

      : HandleVisitor(thread),
        ObjectPointerVisitor(thread->isolate_group()),
        heap_(heap) {}

~GCCompactor()

dart::GCCompactor::~GCCompactor ( )

inline

Definition at line 31 of file compactor.h.

{ free(image_page_ranges_); }

Member Function Documentation

Compact()

void dart::GCCompactor::Compact	(	Page *	pages,
		FreeList *	freelist,
		Mutex *	mutex
	)

Definition at line 184 of file compactor.cc.

                                                                            {
  SetupImagePageBoundaries();
 
  Page* fixed_head = nullptr;
  Page* fixed_tail = nullptr;
 
  // Divide the heap, and set aside never-evacuate pages.
  // TODO(30978): Try to divide based on live bytes or with work stealing.
  intptr_t num_pages = 0;
  Page* page = pages;
  Page* prev = nullptr;
  while (page != nullptr) {
    Page* next = page->next();
    if (page->is_never_evacuate()) {
      if (prev != nullptr) {
        prev->set_next(next);
      } else {
        pages = next;
      }
      if (fixed_tail == nullptr) {
        fixed_tail = page;
      }
      page->set_next(fixed_head);
      fixed_head = page;
    } else {
      prev = page;
      num_pages++;
    }
    page = next;
  }
  fixed_pages_ = fixed_head;
 
  intptr_t num_tasks = FLAG_compactor_tasks;
  RELEASE_ASSERT(num_tasks >= 1);
  if (num_pages < num_tasks) {
    num_tasks = num_pages;
  }
  if (num_tasks == 0) {
    ASSERT(pages == nullptr);
 
    // Move pages to sweeper work lists.
    heap_->old_space()->pages_ = nullptr;
    heap_->old_space()->pages_tail_ = nullptr;
    heap_->old_space()->sweep_regular_ = fixed_head;
 
    heap_->old_space()->Sweep(/*exclusive*/ true);
    heap_->old_space()->SweepLarge();
    return;
  }
 
  Partition* partitions = new Partition[num_tasks];
 
  {
    const intptr_t pages_per_task = num_pages / num_tasks;
    intptr_t task_index = 0;
    intptr_t page_index = 0;
    Page* page = pages;
    Page* prev = nullptr;
    while (task_index < num_tasks) {
      ASSERT(!page->is_never_evacuate());
      if (page_index % pages_per_task == 0) {
        partitions[task_index].head = page;
        partitions[task_index].tail = nullptr;
        if (prev != nullptr) {
          prev->set_next(nullptr);
        }
        task_index++;
      }
      prev = page;
      page = page->next();
      page_index++;
    }
    ASSERT(page_index <= num_pages);
    ASSERT(task_index == num_tasks);
  }
 
  if (FLAG_force_evacuation) {
    // Inject empty pages at the beginning of each worker's list to ensure all
    // objects move and all pages that used to have an object are released.
    // This can be helpful for finding untracked pointers because it prevents
    // an untracked pointer from getting lucky with its target not moving.
    bool oom = false;
    for (intptr_t task_index = 0; task_index < num_tasks && !oom;
         task_index++) {
      const intptr_t pages_per_task = num_pages / num_tasks;
      for (intptr_t j = 0; j < pages_per_task; j++) {
        Page* page = heap_->old_space()->AllocatePage(/* exec */ false,
                                                      /* link */ false);
 
        if (page == nullptr) {
          oom = true;
          break;
        }
 
        FreeListElement::AsElement(page->object_start(),
                                   page->object_end() - page->object_start());
 
        // The compactor slides down: add the empty pages to the beginning.
        page->set_next(partitions[task_index].head);
        partitions[task_index].head = page;
      }
    }
  }
 
  {
    ThreadBarrier* barrier = new ThreadBarrier(num_tasks, 1);
    RelaxedAtomic<intptr_t> next_planning_task = {0};
    RelaxedAtomic<intptr_t> next_setup_task = {0};
    RelaxedAtomic<intptr_t> next_sliding_task = {0};
    RelaxedAtomic<intptr_t> next_forwarding_task = {0};
 
    for (intptr_t task_index = 0; task_index < num_tasks; task_index++) {
      if (task_index < (num_tasks - 1)) {
        // Begin compacting on a helper thread.
        Dart::thread_pool()->Run<CompactorTask>(
            thread()->isolate_group(), this, barrier, &next_planning_task,
            &next_setup_task, &next_sliding_task, &next_forwarding_task,
            num_tasks, partitions, freelist);
      } else {
        // Last worker is the main thread.
        CompactorTask task(thread()->isolate_group(), this, barrier,
                           &next_planning_task, &next_setup_task,
                           &next_sliding_task, &next_forwarding_task, num_tasks,
                           partitions, freelist);
        task.RunEnteredIsolateGroup();
        barrier->Sync();
        barrier->Release();
      }
    }
  }
 
  // Update inner pointers in typed data views (needs to be done after all
  // threads are done with sliding since we need to access fields of the
  // view's backing store)
  //
  // (If the sliding compactor was single-threaded we could do this during the
  // sliding phase: The class id of the backing store can be either accessed by
  // looking at the already-slided-object or the not-yet-slided object. Though
  // with parallel sliding there is no safe way to access the backing store
  // object header.)
  {
    TIMELINE_FUNCTION_GC_DURATION(thread(),
                                  "ForwardTypedDataViewInternalPointers");
    const intptr_t length = typed_data_views_.length();
    for (intptr_t i = 0; i < length; ++i) {
      auto raw_view = typed_data_views_[i];
      const classid_t cid =
          raw_view->untag()->typed_data()->GetClassIdMayBeSmi();
 
      // If we have external typed data we can simply return, since the backing
      // store lives in C-heap and will not move. Otherwise we have to update
      // the inner pointer.
      if (IsTypedDataClassId(cid)) {
        raw_view->untag()->RecomputeDataFieldForInternalTypedData();
      } else {
        ASSERT(IsExternalTypedDataClassId(cid));
      }
    }
  }
 
  for (intptr_t task_index = 0; task_index < num_tasks; task_index++) {
    ASSERT(partitions[task_index].tail != nullptr);
  }
 
  {
    TIMELINE_FUNCTION_GC_DURATION(thread(), "ForwardStackPointers");
    ForwardStackPointers();
  }
 
  {
    TIMELINE_FUNCTION_GC_DURATION(thread(),
                                  "ForwardPostponedSuspendStatePointers");
    // After heap sliding is complete and ObjectStore pointers are forwarded
    // it is finally safe to visit SuspendState objects with copied frames.
    can_visit_stack_frames_ = true;
    const intptr_t length = postponed_suspend_states_.length();
    for (intptr_t i = 0; i < length; ++i) {
      auto suspend_state = postponed_suspend_states_[i];
      suspend_state->untag()->VisitPointers(this);
    }
  }
 
  heap_->old_space()->VisitRoots(this);
 
  {
    MutexLocker ml(pages_lock);
 
    // Free empty pages.
    for (intptr_t task_index = 0; task_index < num_tasks; task_index++) {
      Page* page = partitions[task_index].tail->next();
      while (page != nullptr) {
        Page* next = page->next();
        heap_->old_space()->IncreaseCapacityInWordsLocked(
            -(page->memory_->size() >> kWordSizeLog2));
        page->Deallocate();
        page = next;
      }
    }
 
    // Re-join the heap.
    for (intptr_t task_index = 0; task_index < num_tasks - 1; task_index++) {
      partitions[task_index].tail->set_next(partitions[task_index + 1].head);
    }
    partitions[num_tasks - 1].tail->set_next(nullptr);
    heap_->old_space()->pages_ = pages = partitions[0].head;
    heap_->old_space()->pages_tail_ = partitions[num_tasks - 1].tail;
    if (fixed_head != nullptr) {
      fixed_tail->set_next(heap_->old_space()->pages_);
      heap_->old_space()->pages_ = fixed_head;
 
      ASSERT(heap_->old_space()->pages_tail_ != nullptr);
    }
 
    delete[] partitions;
  }
}

Friends And Related Function Documentation

CompactorTask

friend class CompactorTask

friend

Definition at line 36 of file compactor.h.

---

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

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