dart::CompactorTask Class Reference

Inheritance diagram for dart::CompactorTask:

Public Member Functions
	CompactorTask (IsolateGroup *isolate_group, GCCompactor *compactor, ThreadBarrier *barrier, RelaxedAtomic< intptr_t > *next_planning_task, RelaxedAtomic< intptr_t > *next_setup_task, RelaxedAtomic< intptr_t > *next_sliding_task, RelaxedAtomic< intptr_t > *next_forwarding_task, intptr_t num_tasks, Partition *partitions, FreeList *freelist)
void	Run ()
void	RunEnteredIsolateGroup ()
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 125 of file compactor.cc.

Constructor & Destructor Documentation

CompactorTask()

dart::CompactorTask::CompactorTask ( IsolateGroup *  isolate_group, GCCompactor *  compactor, ThreadBarrier *  barrier, RelaxedAtomic< intptr_t > *  next_planning_task, RelaxedAtomic< intptr_t > *  next_setup_task, RelaxedAtomic< intptr_t > *  next_sliding_task, RelaxedAtomic< intptr_t > *  next_forwarding_task, intptr_t  num_tasks, Partition *  partitions, FreeList *  freelist  )

inline

Definition at line 127 of file compactor.cc.

      : isolate_group_(isolate_group),
        compactor_(compactor),
        barrier_(barrier),
        next_planning_task_(next_planning_task),
        next_setup_task_(next_setup_task),
        next_sliding_task_(next_sliding_task),
        next_forwarding_task_(next_forwarding_task),
        num_tasks_(num_tasks),
        partitions_(partitions),
        freelist_(freelist),
        free_page_(nullptr),
        free_current_(0),
        free_end_(0) {}

Member Function Documentation

Run()

void dart::CompactorTask::Run ( )

virtual

Implements dart::ThreadPool::Task.

Definition at line 401 of file compactor.cc.

                        {
  if (!barrier_->TryEnter()) {
    barrier_->Release();
    return;
  }
 
  bool result =
      Thread::EnterIsolateGroupAsHelper(isolate_group_, Thread::kCompactorTask,
                                        /*bypass_safepoint=*/true);
  ASSERT(result);
 
  RunEnteredIsolateGroup();
 
  Thread::ExitIsolateGroupAsHelper(/*bypass_safepoint=*/true);
 
  // This task is done. Notify the original thread.
  barrier_->Sync();
  barrier_->Release();
}

RunEnteredIsolateGroup()

void dart::CompactorTask::RunEnteredIsolateGroup

(

)

Definition at line 421 of file compactor.cc.

                                           {
#ifdef SUPPORT_TIMELINE
  Thread* thread = Thread::Current();
#endif
  {
    isolate_group_->heap()->old_space()->SweepLarge();
 
    while (true) {
      intptr_t planning_task = next_planning_task_->fetch_add(1u);
      if (planning_task >= num_tasks_) break;
 
      TIMELINE_FUNCTION_GC_DURATION(thread, "Plan");
      Page* head = partitions_[planning_task].head;
      free_page_ = head;
      free_current_ = head->object_start();
      free_end_ = head->object_end();
 
      for (Page* page = head; page != nullptr; page = page->next()) {
        PlanPage(page);
      }
    }
 
    barrier_->Sync();
 
    if (next_setup_task_->fetch_add(1u) == 0) {
      compactor_->SetupLargePages();
    }
 
    barrier_->Sync();
 
    while (true) {
      intptr_t sliding_task = next_sliding_task_->fetch_add(1u);
      if (sliding_task >= num_tasks_) break;
 
      TIMELINE_FUNCTION_GC_DURATION(thread, "Slide");
      Page* head = partitions_[sliding_task].head;
      free_page_ = head;
      free_current_ = head->object_start();
      free_end_ = head->object_end();
 
      for (Page* page = head; page != nullptr; page = page->next()) {
        SlidePage(page);
      }
 
      // Add any leftover in the last used page to the freelist. This is
      // required to make the page walkable during forwarding, etc.
      intptr_t free_remaining = free_end_ - free_current_;
      if (free_remaining != 0) {
        freelist_->Free(free_current_, free_remaining);
      }
 
      ASSERT(free_page_ != nullptr);
      partitions_[sliding_task].tail = free_page_;  // Last live page.
 
      {
        TIMELINE_FUNCTION_GC_DURATION(thread, "ForwardLargePages");
        compactor_->ForwardLargePages();
      }
    }
 
    // Heap: Regular pages already visited during sliding. Code and image pages
    // have no pointers to forward. Visit large pages and new-space.
 
    bool more_forwarding_tasks = true;
    while (more_forwarding_tasks) {
      intptr_t forwarding_task = next_forwarding_task_->fetch_add(1u);
      switch (forwarding_task) {
        case 0: {
          TIMELINE_FUNCTION_GC_DURATION(thread, "ForwardNewSpace");
          isolate_group_->heap()->new_space()->VisitObjectPointers(compactor_);
          break;
        }
        case 1: {
          TIMELINE_FUNCTION_GC_DURATION(thread, "ForwardRememberedSet");
          isolate_group_->store_buffer()->VisitObjectPointers(compactor_);
          break;
        }
        case 2: {
          TIMELINE_FUNCTION_GC_DURATION(thread, "ForwardWeakTables");
          isolate_group_->heap()->ForwardWeakTables(compactor_);
          break;
        }
        case 3: {
          TIMELINE_FUNCTION_GC_DURATION(thread, "ForwardWeakHandles");
          isolate_group_->VisitWeakPersistentHandles(compactor_);
          break;
        }
#ifndef PRODUCT
        case 4: {
          TIMELINE_FUNCTION_GC_DURATION(thread, "ForwardObjectIdRing");
          isolate_group_->ForEachIsolate(
              [&](Isolate* isolate) {
                ObjectIdRing* ring = isolate->object_id_ring();
                if (ring != nullptr) {
                  ring->VisitPointers(compactor_);
                }
              },
              /*at_safepoint=*/true);
          break;
        }
#endif  // !PRODUCT
        default:
          more_forwarding_tasks = false;
      }
    }
  }
}

---

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

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