ART MarkSweep GC MarkingPhase

MarkingPhase 步骤

• BindBitmaps()
• FindDefaultSpaceBitmap()
• heap->ProcessCards()
• MarkRoots()
• MarkReachableObjects()
• PreCleanCards()

1.BindBitmaps()

Mark Object 是通过 bitmap 来标志整个 heap上的 objects是否被标记的。

在 MarkSweep collector中，BindBitmaps()实现如下：

void MarkSweep::BindBitmaps() {
  TimingLogger::ScopedTiming t(__FUNCTION__, GetTimings());
  WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
  // Mark all of the spaces we never collect as immune.
  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
    if (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyNeverCollect) {
      immune_spaces_.AddSpace(space);
    }
  }
}

遍历了所有的 continuous space，如果这个 space 对应的GC回收策略是 kGcRetentionPolicyNeverCollect，则把这个 space 加入到GC豁免集合中；

immune_spaces_ 是 ImmuneSpaces 类型对象。

把 space 添加到 immune_spaces_的意思是，豁免space内的所有 object都不会被回收，在 GC过程中也不需要被 mark。

另外，需要说明的是：只有 ImageSpace的回收策略是 kGcRetentionPolicyNeverCollect，即永不回收。

在ART中可能有一个或多个 image space，这是因为Android支持mutiImage，比如常见到的 boot.art, boot-framework.art, boot-***.art 都是作为ImageSpace添加到Heap中的。

我们看下 ImmuneSpace 的 AddSpace（） 函数做了什么事情：

void ImmuneSpaces::AddSpace(space::ContinuousSpace* space) {
  DCHECK(spaces_.find(space) == spaces_.end()) << *space;
  // Bind live to mark bitmap if necessary.
  if (space->GetLiveBitmap() != space->GetMarkBitmap()) {
    CHECK(space->IsContinuousMemMapAllocSpace());
    space->AsContinuousMemMapAllocSpace()->BindLiveToMarkBitmap();
  }
  spaces_.insert(space);
  CreateLargestImmuneRegion();
}

1.被豁免的 space 的 live_bitmap 如果不等于 mark_bitmap，会通过 BindLiveToMarkBitmap，把 mark_bitmap_ 设置为 live_bitmap_，

并把 Heap中 mark_bitmap_ 中记录的该 space的 mark_bitmap_ 更改为记录 live_bitmap_。（这是因为 live_bitmap == mark_bitmap_时，再 MarkSweep的 Sweep函数中，就直接返回了）

2.把这个这个space添加到 ImmuneSpace 的 set 数据集合 spaces_ 中；

3.每添加一个 space，尝试重新为 ImmuneSpace 创建 ImmuneRegion，或者把 space 追加到 ImmuneRegion的末尾。这个过程可能会创建多个 ImmuneReion，但最终我们使用最大的那个。

用来做 fast  path lookup，这样的效率较高；比如：

  ALWAYS_INLINE bool ContainsObject(const mirror::Object* obj) const {
    if (largest_immune_region_.ContainsObject(obj)) {
      return true;
    }
    for (space::ContinuousSpace* space : spaces_) {
      if (space->HasAddress(obj)) {
        return true;
      }
    }
    return false;
  }

在这段代码中，第一个 if 语句的命中率较高，减少查找搜寻操作。理论上是这个意思，具体实际效果如何，未做确认。

总结：BindBitmaps() 主要就是设置 ImageSpace 不被回收，GC 时也不用标记，并设置 ImmuneSpace，ImmuneRegion。

2.FindDefaultSpaceBitmap()

这个函数的功能是为了找出 main space 中的 Bitmap作为 default 的bitmap，实际也是为了提高效率，因为我么知道，GC 回收，实际回收最多的就是main space，它是GC 回收的主要目标，所以把它的 bitmap作为 default 可以提升效率。代码如下：

void MarkSweep::FindDefaultSpaceBitmap() {
  TimingLogger::ScopedTiming t(__FUNCTION__, GetTimings());
  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
    accounting::ContinuousSpaceBitmap* bitmap = space->GetMarkBitmap();
    // We want to have the main space instead of non moving if possible.
    if (bitmap != nullptr &&
        space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect) {
      current_space_bitmap_ = bitmap;
      // If we are not the non moving space exit the loop early since this will be good enough.
      if (space != heap_->GetNonMovingSpace()) {
        break;
      }
    }
  }
  CHECK(current_space_bitmap_ != nullptr) << "Could not find a default mark bitmap\n"
      << heap_->DumpSpaces();
}

ART Heap中回收策略为 kGcRetentionPolicyAlwaysCollect 的space类型有 BumpPointerSpace，MallocSpace（子类 DlMallocSpace，RosAllocSpace），RegionSpace，LargeObjectSpace。

其中 BumpPointerSpace 和 RegionSpace 没有使用，而 LargeObjectSpace是 DisContinuousSpace，所以这里满足条件的只有 DlMallocSpace 和 RosAllocSpace 类型的 space。

而实际上 main_space_ 是 RosAllocSpace，并会被设置为 heap->rosalloc_space_ = main_space_.

non_moving_space_ 实际上是 DlMallocSpace 类型的，注释里说 non_moving_space_ 必须是 DlMallocSpace，因为当前不支持多个活动的 RosAllocSpace（原因待调查）。

另外，main_space_backup_ 实际上是 RosAllocSpace，所以说，main_space_backup_不会和 main_space_ 同时活动的。main_space_backup_在创建的时候是先通过AddSpace()添加，后又条用 RemoveSpace()删除掉了。（为什么添加又删除 ？）

总结：FindDefaultSpaceBitmap() 主要是为了 GC 的效率考虑，把最常访问的，最容易命中的 main_space_ 的 bitmap作为 current_space_bitmap_.

3.heap->ProcessCards()

这一步主要是为了处理 ZygoteSpace 和 ImageSpace 的 ModUnionTable，以及清空 AllocSapce 的 CardTable。还是看代码：

void Heap::ProcessCards(TimingLogger* timings,
                        bool use_rem_sets,
                        bool process_alloc_space_cards,
                        bool clear_alloc_space_cards) {
  TimingLogger::ScopedTiming t(__FUNCTION__, timings);
  // Clear cards and keep track of cards cleared in the mod-union table.
  for (const auto& space : continuous_spaces_) {
    accounting::ModUnionTable* table = FindModUnionTableFromSpace(space);
    accounting::RememberedSet* rem_set = FindRememberedSetFromSpace(space);
    if (table != nullptr) {
      const char* name = space->IsZygoteSpace() ? "ZygoteModUnionClearCards" :
          "ImageModUnionClearCards";
      TimingLogger::ScopedTiming t2(name, timings);
      table->ProcessCards();
    } else if (use_rem_sets && rem_set != nullptr) {
      DCHECK(collector::SemiSpace::kUseRememberedSet && collector_type_ == kCollectorTypeGSS)
          << static_cast(collector_type_);
      TimingLogger::ScopedTiming t2("AllocSpaceRemSetClearCards", timings);
      rem_set->ClearCards();
    } else if (process_alloc_space_cards) {
      TimingLogger::ScopedTiming t2("AllocSpaceClearCards", timings);
      if (clear_alloc_space_cards) {
        uint8_t* end = space->End();
        if (space->IsImageSpace()) {
          // Image space end is the end of the mirror objects, it is not necessarily page or card
          // aligned. Align up so that the check in ClearCardRange does not fail.
          end = AlignUp(end, accounting::CardTable::kCardSize);
        }
        card_table_->ClearCardRange(space->Begin(), end);
      } else {
        // No mod union table for the AllocSpace. Age the cards so that the GC knows that these
        // cards were dirty before the GC started.
        // TODO: Need to use atomic for the case where aged(cleaning thread) -> dirty(other thread)
        // -> clean(cleaning thread).
        // The races are we either end up with: Aged card, unaged card. Since we have the
        // checkpoint roots and then we scan / update mod union tables after. We will always
        // scan either card. If we end up with the non aged card, we scan it it in the pause.
        card_table_->ModifyCardsAtomic(space->Begin(), space->End(), AgeCardVisitor(),
                                       VoidFunctor());
      }
    }
  }
}

当collector是 MarkSweep时，ProcessCards的参数是 （timing，fase，true，true）。所以会走如下逻辑：

• ZygoteSpace 和 ImageSpace 会调用各自 ModUnionTable 的 ProcessCards() 函数
• Alloc Space 会清空它们的范围对应的 card table

1. 先看下ImageSpace的 ModUnionTable的 ProcessCards 做了什么：

void ModUnionTableReferenceCache::ProcessCards() {
  CardTable* card_table = GetHeap()->GetCardTable();
  ModUnionAddToCardSetVisitor visitor(&cleared_cards_);
  // Clear dirty cards in the this space and update the corresponding mod-union bits.
  card_table->ModifyCardsAtomic(space_->Begin(), space_->End(), AgeCardVisitor(), visitor);
}

在这个函数里主要做了以下事情：

• 通过AgeCardVisitor 把当前ImageSpace对应的所有 dirty card(0x70)清除(修改为 0x6f)，非 dirty card都设置为 clean card(0x0)
• 这些 dirty card 被清除后，会记录在当前 ModUionTable的成员 CardSet cleared_cards_中,这个 cleared_cards_是用来 update mod-union table的，具体怎么update，等待调查

2. ZygoteSpace的 ModUnionTable 的 ProcessCards 函数：

void ModUnionTableCardCache::ProcessCards() {
  CardTable* const card_table = GetHeap()->GetCardTable();
  ModUnionAddToCardBitmapVisitor visitor(card_bitmap_.get(), card_table);
  // Clear dirty cards in the this space and update the corresponding mod-union bits.
  card_table->ModifyCardsAtomic(space_->Begin(), space_->End(), AgeCardVisitor(), visitor);
}

这个函数中也是做了两件事情：

• 通过 AgeCardVisitor 把 ZygoteSpace 对应的 .....(同上)
• 会使用当前 ModUnionTable 的 CardBitmap card_bitmap_ 把这些被从 dirty 状态改到 0x6f 状态的 card 记录下来，据说也是用来 update mod-union table的

3. 清空 Alloc Space 对应的 CardTable：

void CardTable::ClearCardRange(uint8_t* start, uint8_t* end) {
  CHECK_ALIGNED(reinterpret_cast(start), kCardSize);
  CHECK_ALIGNED(reinterpret_cast(end), kCardSize);
  static_assert(kCardClean == 0, "kCardClean must be 0");
  uint8_t* start_card = CardFromAddr(start);
  uint8_t* end_card = CardFromAddr(end);
  ZeroAndReleasePages(start_card, end_card - start_card);
}

这个函数把space 对应的 card table内存，整page的部分 madvise DONT_NEEDED，非整部分的内存填充为 0x0.

总结：heap->ProcessCards 清理 ImageSpace和ZygoteSpace对应的  card table，并记录下来；清零 Alloc space对应的 card table，并建议回收 card table 对应内存。

4.MarkRoots()

真正的 Mark 来了，其实前面3点都还在为 Mark 做准备，在 MarkRoots() 函数里，会 Mark 当前虚拟机中的所有 GC Root；它分为如下几个部分：

• MarkRootsCheckpoint(self, kRevokeRosAllocThreadLocalBuffersAtCheckpoint);
• MarkNonThreadRoots();
• MarkConcurrentRoots(
          static_cast(kVisitRootFlagAllRoots | kVisitRootFlagStartLoggingNewRoots));

4.1 MarkRootsCheckpoint() 通过 RunCheckpoint() 标记所有 thread 对应的 GC Root，并撤回所有线程的 Thread local buffer

这里我们主要看下 Mark Thread roots 使用的 Checkpoint 的是CheckpointMarkThreadRoots，主要实现:

  virtual void Run(Thread* thread) OVERRIDE NO_THREAD_SAFETY_ANALYSIS {
    ScopedTrace trace("Marking thread roots");
    // Note: self is not necessarily equal to thread since thread may be suspended.
    Thread* const self = Thread::Current();
    CHECK(thread == self || thread->IsSuspended() || thread->GetState() == kWaitingPerformingGc)
        << thread->GetState() << " thread " << thread << " self " << self;
    thread->VisitRoots(this);
    if (revoke_ros_alloc_thread_local_buffers_at_checkpoint_) {
      ScopedTrace trace2("RevokeRosAllocThreadLocalBuffers");
      mark_sweep_->GetHeap()->RevokeRosAllocThreadLocalBuffers(thread);
    }
    // If thread is a running mutator, then act on behalf of the garbage collector.
    // See the code in ThreadList::RunCheckpoint.
    mark_sweep_->GetBarrier().Pass(self);
  }

对于 Runnable状态的线程执行到 Suspend point的时候，会自动执行这个 Run 函数，对于 Suspended 状态的线程，会由当前 GC 线程帮助对其进行 VisitRoots(RootVistor v)操作，由于当前RootVisitor 的功能是Mark，所以在Visit之后，就会Mark当前的 Thread Roots.然后撤回当前 Thread 的 RosAllocThreadLocalBuffers。

下面我们来看下每个线程的 Thread Roots 是如何来进行 Visit的:

void Thread::VisitRoots(RootVisitor* visitor) {
  const uint32_t thread_id = GetThreadId();
  visitor->VisitRootIfNonNull(&tlsPtr_.opeer, RootInfo(kRootThreadObject, thread_id));
  if (tlsPtr_.exception != nullptr && tlsPtr_.exception != GetDeoptimizationException()) {
    visitor->VisitRoot(reinterpret_cast(&tlsPtr_.exception),
                       RootInfo(kRootNativeStack, thread_id));
  }
  visitor->VisitRootIfNonNull(&tlsPtr_.monitor_enter_object, RootInfo(kRootNativeStack, thread_id));
  tlsPtr_.jni_env->locals.VisitRoots(visitor, RootInfo(kRootJNILocal, thread_id));
  tlsPtr_.jni_env->monitors.VisitRoots(visitor, RootInfo(kRootJNIMonitor, thread_id));
  HandleScopeVisitRoots(visitor, thread_id);
  if (tlsPtr_.debug_invoke_req != nullptr) {
    tlsPtr_.debug_invoke_req->VisitRoots(visitor, RootInfo(kRootDebugger, thread_id));
  }
  // Visit roots for deoptimization.
  if (tlsPtr_.stacked_shadow_frame_record != nullptr) {
    RootCallbackVisitor visitor_to_callback(visitor, thread_id);
    ReferenceMapVisitor mapper(this, nullptr, visitor_to_callback);
    for (StackedShadowFrameRecord* record = tlsPtr_.stacked_shadow_frame_record;
         record != nullptr;
         record = record->GetLink()) {
      for (ShadowFrame* shadow_frame = record->GetShadowFrame();
           shadow_frame != nullptr;
           shadow_frame = shadow_frame->GetLink()) {
        mapper.VisitShadowFrame(shadow_frame);
      }
    }
  }
  for (DeoptimizationContextRecord* record = tlsPtr_.deoptimization_context_stack;
       record != nullptr;
       record = record->GetLink()) {
    if (record->IsReference()) {
      visitor->VisitRootIfNonNull(record->GetReturnValueAsGCRoot(),
                                  RootInfo(kRootThreadObject, thread_id));
    }
    visitor->VisitRootIfNonNull(record->GetPendingExceptionAsGCRoot(),
                                RootInfo(kRootThreadObject, thread_id));
  }
  if (tlsPtr_.frame_id_to_shadow_frame != nullptr) {
    RootCallbackVisitor visitor_to_callback(visitor, thread_id);
    ReferenceMapVisitor mapper(this, nullptr, visitor_to_callback);
    for (FrameIdToShadowFrame* record = tlsPtr_.frame_id_to_shadow_frame;
         record != nullptr;
         record = record->GetNext()) {
      mapper.VisitShadowFrame(record->GetShadowFrame());
    }
  }
  for (auto* verifier = tlsPtr_.method_verifier; verifier != nullptr; verifier = verifier->link_) {
    verifier->VisitRoots(visitor, RootInfo(kRootNativeStack, thread_id));
  }
  // Visit roots on this thread's stack
  Context* context = GetLongJumpContext();
  RootCallbackVisitor visitor_to_callback(visitor, thread_id);
  ReferenceMapVisitor mapper(this, context, visitor_to_callback);
  mapper.template WalkStack(false);
  ReleaseLongJumpContext(context);
  for (instrumentation::InstrumentationStackFrame& frame : *GetInstrumentationStack()) {
    visitor->VisitRootIfNonNull(&frame.this_object_, RootInfo(kRootVMInternal, thread_id));
  }
}

看第一个 ： visitor->VisitRootIfNonNull(&tlsPtr_.opeer,..); 由于当前 visitor是 CheckpointMarkThreadRoots，继承自 RootVisitor，其这个函数 VisitRootIfNonNull()是在 RootVisitor中实现的，基本执行流程如下图：

简单来讲，这个流程就是 mark 一个 obj 到对应 bitmap 的 bit 位，并把它 push 到 mark_stack_ ，以便递归标记子节点。

接下来看，Thread::VisitRoots()，这个函数里包含了一个 Thread 的所有需要被 Visit的内容，下面是一个thred中需要被标记的内容：

总结：MarkRootsCheckPoint() 就是要把当前进程所有 thread 所必须的一些对象标记上，这些对象是 GCRoot，当从 mark_stack_递归标记时，就相当于从根集对象 GCRoots 依次标记他们引用的对象了。

RevokeRosAllocThreadLocalBuffers就不再细说了。

4.2 MarkNonThreadRoots();

看代码：

void MarkSweep::MarkNonThreadRoots() {
  TimingLogger::ScopedTiming t(__FUNCTION__, GetTimings());
  Runtime::Current()->VisitNonThreadRoots(this);
}

void Runtime::VisitNonThreadRoots(RootVisitor* visitor) {
  java_vm_->VisitRoots(visitor);
  sentinel_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
  pre_allocated_OutOfMemoryError_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
  pre_allocated_NoClassDefFoundError_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
  verifier::MethodVerifier::VisitStaticRoots(visitor);
  VisitTransactionRoots(visitor);
}

实际上就是通过 Runtime 去标记一些全局的object。

• 通过 java_vm_ 标记 Global Reference Table中所有的 IndirectReference
• 标记全局对象 sentinel_
• 标记全局 Throwable对象 pre_allocated_OutOfMemoryError_
• 标记全局 Throwable对象 pre_allocated_NoClassDefFoundError_
• 标记基础对象类型，比如ShortType, IntegerType
• 当在一个 transaction 过程时，需要 mark transaction 中的对象
  

4.3 MarkConcurrentRoots()

void MarkSweep::MarkConcurrentRoots(VisitRootFlags flags) {
  TimingLogger::ScopedTiming t(__FUNCTION__, GetTimings());
  // Visit all runtime roots and clear dirty flags.
  Runtime::Current()->VisitConcurrentRoots(this, flags);
}

void Runtime::VisitConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
  intern_table_->VisitRoots(visitor, flags);
  class_linker_->VisitRoots(visitor, flags);
  heap_->VisitAllocationRecords(visitor);
  if ((flags & kVisitRootFlagNewRoots) == 0) {
    // Guaranteed to have no new roots in the constant roots.
    VisitConstantRoots(visitor);
  }
  Dbg::VisitRoots(visitor);
}

通过 Runtime 标记全局对象：

• 标记intern_table_ 中 strong_interns_包含的所有 String对象
• classlinker 标记 class_roots_ array 对象，interface table对象，boot_class_table_中的class，strong_roots_(dexfile或者dexcache), oat_files_; 标记所有 class_loaders
• heap 这个是为了在 alloc track开启的情况下，标记 record信息
• Visit flag设置 kVisitRootFlagNewRoots的情况下，标记 constant roots
• Dbg 相关的对象的标记
  

总结：MarkRoots() 就是为了标记不能被回收的根集对象，并 push 到 mark_stack_中，后面才能根据这些对象递归的标记可达对象，简单的理解，这些标记完成后，就可以回收那些没有被标记的对象了。

5.MarkReachableObjects()

在上面标记完根集对象之后，就可以递归标记可达对象了。

void MarkSweep::MarkReachableObjects() {
  UpdateAndMarkModUnion();
  // Recursively mark all the non-image bits set in the mark bitmap.
  RecursiveMark();
}

1.UpdateAndMarkModUnion

void MarkSweep::UpdateAndMarkModUnion() {
  for (const auto& space : immune_spaces_.GetSpaces()) {
    const char* name = space->IsZygoteSpace()
        ? "UpdateAndMarkZygoteModUnionTable"
        : "UpdateAndMarkImageModUnionTable";
    DCHECK(space->IsZygoteSpace() || space->IsImageSpace()) << *space;
    TimingLogger::ScopedTiming t(name, GetTimings());
    accounting::ModUnionTable* mod_union_table = heap_->FindModUnionTableFromSpace(space);
    if (mod_union_table != nullptr) {
      mod_union_table->UpdateAndMarkReferences(this);
    } else {
      // No mod-union table, scan all the live bits. This can only occur for app images.
      space->GetLiveBitmap()->VisitMarkedRange(reinterpret_cast(space->Begin()),
                                               reinterpret_cast(space->End()),
                                               ScanObjectVisitor(this));
    }
  }
}

主要是通过 image space/ zygote space 的 mod_uion_table 记录的 cleared_cards_ 和 card_bitmap_ 进行标记对应的 space的对象；

对于 App image ，则通过获取其 space的 live bitmap来标记对象；

2.RecursiveMark()

递归标记，主要代码是：

void MarkSweep::RecursiveMark() {
  ProcessMarkStack(false);
}

记得我们在 MarkRoots() 时，把 GCRoots 都保存在 mark_stack_中了，这里就通过这个 mark_stack_ 来标记  GC Roots 引用的对象。

ProcessMarkStack() 可以多个 thread 并行，也可以一个thread执行，总的原理就是：

  MarkVisitor mark_visitor(this);
  DelayReferenceReferentVisitor ref_visitor(this);
  ScanObjectVisit(obj, mark_visitor, ref_visitor);

template
inline void MarkSweep::ScanObjectVisit(mirror::Object* obj,
                                       const MarkVisitor& visitor,
                                       const ReferenceVisitor& ref_visitor) {
  DCHECK(IsMarked(obj)) << "Scanning unmarked object " << obj << "\n" << heap_->DumpSpaces();
  obj->VisitReferences(visitor, ref_visitor);
}

通过 ScanObjectVisit() 来Visit 目标 obj：

• 首先标记 obj 对象的 klass 对象
• 如果其 klass 是个 kClassFlagNormal，则使用 VisitInstanceFieldsReferences() 标记当前 obj 的引用对象
• kClassFlagClass 类型的class，单独进行处理
• kClassFlagObjectArray 类型的class，单独进行处理
• kClassFlagReference 类型的class，首先通过 VisitInstanceFieldsReferences标记引用对象，然后通过  DelayReferenceReferentVisitor 处理此类对象
  
• kClassFlagDexCache 和 class loader类型的对象，也单独进行标记
  

看下 Reference类型对象的处理是通过 ReferenceProcessor 的 DelayReferenceReferent() 函数进行处理：

void ReferenceProcessor::DelayReferenceReferent(ObjPtr klass,
                                                ObjPtr ref,
                                                collector::GarbageCollector* collector) {
  mirror::HeapReference* referent = ref->GetReferentReferenceAddr();
  if (!collector->IsNullOrMarkedHeapReference(referent, /*do_atomic_update*/true)) {
    if (klass->IsSoftReferenceClass()) {
      soft_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
    } else if (klass->IsWeakReferenceClass()) {
      weak_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
    } else if (klass->IsFinalizerReferenceClass()) {
      finalizer_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
    } else if (klass->IsPhantomReferenceClass()) {
      phantom_reference_queue_.AtomicEnqueueIfNotEnqueued(self, ref);
    } else {
      LOG(FATAL) << "Invalid reference type " << klass->PrettyClass() << " " << std::hex
                 << klass->GetAccessFlags();
    }
  }
}

我们看到，这里会把各类 Reference类型的独享，放到各自的 reference queue中，会等到 GC Reclaim Phase 统一处理。

总结：MarkReachableObjects() 目的就是递归标记 MarkRoots() 阶段找出来的 GCRoot根集对象，其中对不同的 类型的 Object会做一些特殊处理，比如 Reference类型的 obj。

6.PreCleanCards()

这一步的官方注释是：   // Pre-clean dirtied cards to reduce pauses.

意思就是在 MarkingPhase 函数结束的时候，其实已经过去了一小段时间，如果是 concurrnet GC，那么这段时间，一些对象的访问，修改等，应该已经产生了一些 Dirty card。如果不是 concurrent GC则不会，那么 PreCleanCards() 函数里不会再执行。

在 concurrent GC的情况，我们在这里，先通过 PreCleanCards() 来处理一些 dirty card，以减少后面 pause阶段的工作，这样 pause 阶段时间减少，能够更好的减少卡顿。实现如下：

void MarkSweep::PreCleanCards() {
  // Don't do this for non concurrent GCs since they don't have any dirty cards.
  if (kPreCleanCards && IsConcurrent()) {
    TimingLogger::ScopedTiming t(__FUNCTION__, GetTimings());
    Thread* self = Thread::Current();
    CHECK(!Locks::mutator_lock_->IsExclusiveHeld(self));
    // Process dirty cards and add dirty cards to mod union tables, also ages cards.
    heap_->ProcessCards(GetTimings(), false, true, false);
    // The checkpoint root marking is required to avoid a race condition which occurs if the
    // following happens during a reference write:
    // 1. mutator dirties the card (write barrier)
    // 2. GC ages the card (the above ProcessCards call)
    // 3. GC scans the object (the RecursiveMarkDirtyObjects call below)
    // 4. mutator writes the value (corresponding to the write barrier in 1.)
    // This causes the GC to age the card but not necessarily mark the reference which the mutator
    // wrote into the object stored in the card.
    // Having the checkpoint fixes this issue since it ensures that the card mark and the
    // reference write are visible to the GC before the card is scanned (this is due to locks being
    // acquired / released in the checkpoint code).
    // The other roots are also marked to help reduce the pause.
    MarkRootsCheckpoint(self, false);
    MarkNonThreadRoots();
    MarkConcurrentRoots(
        static_cast(kVisitRootFlagClearRootLog | kVisitRootFlagNewRoots));
    // Process the newly aged cards.
    RecursiveMarkDirtyObjects(false, accounting::CardTable::kCardDirty - 1);
    // TODO: Empty allocation stack to reduce the number of objects we need to test / mark as live
    // in the next GC.
  }
}

MarkingPhase 流程总结：