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
Public Member Functions inherited from dart::ObjectPointerVisitor
	ObjectPointerVisitor (IsolateGroup *isolate_group)
virtual	~ObjectPointerVisitor ()
IsolateGroup *	isolate_group () const
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

Private Member Functions
void	VisitTypedDataViewPointers (TypedDataViewPtr view, CompressedObjectPtr *first, CompressedObjectPtr *last) override
void	VisitPointers (ObjectPtr *first, ObjectPtr *last) override
bool	CanVisitSuspendStatePointers (SuspendStatePtr suspend_state) override
void	VisitHandle (uword addr) override

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

CanVisitSuspendStatePointers()

bool dart::GCCompactor::CanVisitSuspendStatePointers ( SuspendStatePtr  suspend_state )

overrideprivatevirtual

Reimplemented from dart::ObjectPointerVisitor.

Definition at line 765 of file compactor.cc.

                                                                            {
  if ((suspend_state->untag()->pc() != 0) && !can_visit_stack_frames_) {
    // Visiting pointers of SuspendState objects with copied stack frame
    // needs to query stack map, which can touch other Dart objects
    // (such as GrowableObjectArray of InstructionsTable).
    // Those objects may have an inconsistent state during compaction,
    // so processing of SuspendState objects is postponed to the later
    // stage of compaction.
    MutexLocker ml(&postponed_suspend_states_mutex_);
    postponed_suspend_states_.Add(suspend_state);
    return false;
  }
  return true;
}

Compact()

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

Definition at line 184 of file compactor.cc.

                                                                            {
  SetupImagePageBoundaries();
 
  // Divide the heap.
  // TODO(30978): Try to divide based on live bytes or with work stealing.
  intptr_t num_pages = 0;
  for (Page* page = pages; page != nullptr; page = page->next()) {
    num_pages++;
  }
 
  intptr_t num_tasks = FLAG_compactor_tasks;
  RELEASE_ASSERT(num_tasks >= 1);
  if (num_pages < num_tasks) {
    num_tasks = num_pages;
  }
 
  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) {
      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;
 
    delete[] partitions;
  }
}

VisitHandle()

void dart::GCCompactor::VisitHandle ( uword  addr )

overrideprivatevirtual

Implements dart::HandleVisitor.

Definition at line 780 of file compactor.cc.

                                        {
  FinalizablePersistentHandle* handle =
      reinterpret_cast<FinalizablePersistentHandle*>(addr);
  ForwardPointer(handle->ptr_addr());
}

VisitPointers()

void dart::GCCompactor::VisitPointers ( ObjectPtr *  first, ObjectPtr *  last  )

overrideprivatevirtual

Implements dart::ObjectPointerVisitor.

Definition at line 749 of file compactor.cc.

                                                                 {
  for (ObjectPtr* ptr = first; ptr <= last; ptr++) {
    ForwardPointer(ptr);
  }
}

VisitTypedDataViewPointers()

void dart::GCCompactor::VisitTypedDataViewPointers ( TypedDataViewPtr  view, CompressedObjectPtr *  first, CompressedObjectPtr *  last  )

overrideprivatevirtual

Reimplemented from dart::ObjectPointerVisitor.

Definition at line 713 of file compactor.cc.

                                                                        {
  // First we forward all fields of the typed data view.
  ObjectPtr old_backing = view->untag()->typed_data();
  VisitCompressedPointers(view->heap_base(), first, last);
  ObjectPtr new_backing = view->untag()->typed_data();
 
  const bool backing_moved = old_backing != new_backing;
  if (backing_moved) {
    // The backing store moved, so we *might* need to update the view's inner
    // pointer. If the backing store is internal typed data we *have* to update
    // it, otherwise (in case of external typed data) we don't have to.
    //
    // Unfortunately we cannot find out whether the backing store is internal
    // or external during sliding phase: Even though we know the old and new
    // location of the backing store another thread might be responsible for
    // moving it and we have no way to tell when it got moved.
    //
    // So instead we queue all those views up and fix their inner pointer in a
    // final phase after compaction.
    MutexLocker ml(&typed_data_view_mutex_);
    typed_data_views_.Add(view);
  } else {
    // The backing store didn't move, we therefore don't need to update the
    // inner pointer.
    if (view->untag()->data_ == nullptr) {
      ASSERT(RawSmiValue(view->untag()->offset_in_bytes()) == 0 &&
             RawSmiValue(view->untag()->length()) == 0 &&
             view->untag()->typed_data() == Object::null());
    }
  }
}

Friends And Related Symbol 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