G1 Young GC 之准备阶段

//调用链
//->mem_allocate->attempt_allocation->attempt_allocation_slow
//->do_collection_pause->VMThread::execute(&op)
//inner_execute-> evaluate_operation-> op->evaluate()
//->do_collection_pause_at_safepoint

void G1CollectedHeap::do_collection_pause_at_safepoint_helper() {

  policy()->decide_on_concurrent_start_pause(); //是否要进行并发标记判断

  G1YoungCollector collector(gc_cause());
  collector.collect(); // Young GC
   
  if (collector_state()->in_concurrent_start_gc()) {//是否执行并发标记
    start_concurrent_cycle(collector.concurrent_operation_is_full_mark());
  }
}

void G1YoungCollector::collect() {
    set_young_collection_default_active_worker_threads(); 
    wait_for_root_region_scanning();
    {
        pre_evacuate_collection_set(jtm.evacuation_info()); 
        // Actually do the work...
        evacuate_initial_collection_set(&per_thread_states, may_do_optional_evacuation);
        if (may_do_optional_evacuation) {
          evacuate_optional_collection_set(&per_thread_states);
        }
        post_evacuate_collection_set(jtm.evacuation_info(), &per_thread_states); 
    }
}

void G1YoungCollector::pre_evacuate_collection_set(G1EvacInfo* evacuation_info) {
// Flush various data in thread-local buffers to be able to determine the collection  set
    G1PreEvacuateCollectionSetBatchTask cl;

    calculate_collection_set(evacuation_info, policy()->max_pause_time_ms())
    
    if (collector_state()->in_concurrent_start_gc()) {
    concurrent_mark()->pre_concurrent_start(_gc_cause); }
    
   // how reference processing currently works in G1.
   ref_processor_stw()->start_discovery(false /* always_clear */);
   
   _evac_failure_regions.pre_collection(_g1h->max_reserved_regions());
   
     // Initialize the GC alloc regions.
   allocator()->init_gc_alloc_regions(evacuation_info);
  
   rem_set()->prepare_for_scan_heap_roots();
   _g1h->prepare_group_cardsets_for_scan();
   
   G1PrepareEvacuationTask g1_prep_task(_g1h);
}

G1PreEvacuateCollectionSetBatchTask::G1PreEvacuateCollectionSetBatchTask() :
  G1BatchedTask("Pre Evacuate Prepare", G1CollectedHeap::heap()->phase_times()),
  _old_pending_cards(G1BarrierSet::dirty_card_queue_set().num_cards()),
  _java_retire_task(new JavaThreadRetireTLABAndFlushLogs()),
  _non_java_retire_task(new NonJavaThreadFlushLogs()) {

  // Disable mutator refinement until concurrent refinement decides otherwise.
  G1BarrierSet::dirty_card_queue_set().set_mutator_refinement_threshold(SIZE_MAX);

  add_serial_task(_non_java_retire_task);
  add_parallel_task(_java_retire_task);
}

class G1PreEvacuateCollectionSetBatchTask : class G1BatchedTask : public WorkerTask {
    void G1BatchedTask::work(uint worker_id) {
      int t = 0;
      while (try_claim_serial_task(t)) {
        G1AbstractSubTask* task = _serial_tasks.at(t);
        task->do_work(worker_id);
      }
      for (G1AbstractSubTask* task : _parallel_tasks) {
        task->do_work(worker_id);
  } } }

class G1PreEvacuateCollectionSetBatchTask::JavaThreadRetireTLABAndFlushLogs : public G1AbstractSubTask {
    G1JavaThreadsListClaimer _claimer;
  // There is relatively little work to do per thread.
  static const uint ThreadsPerWorker = 250
  
    JavaThreadRetireTLABAndFlushLogs() :
    _claimer(ThreadsPerWorker) { }

  void do_work(uint worker_id) override {
    RetireTLABAndFlushLogsClosure tc;
    _claimer.apply(&tc);
  }
}

inline void G1JavaThreadsListClaimer::apply(ThreadClosure* cl) {
  JavaThread* const* list; uint count;

  while ((list = claim(count)) != nullptr) {//所有的 GC 工作线程会并行执行到这里
    for (uint i = 0; i < count; i++) {
      cl->do_thread(list[i]);
    } } }

inline JavaThread* const* G1JavaThreadsListClaimer::claim(uint& count) {
  count = 0;
  uint claim = Atomic::fetch_then_add(&_cur_claim, _claim_step); //保证原子性
  count = MIN2(_list.length() - claim, _claim_step);
  return _list.list()->threads() + claim;
}

struct RetireTLABAndFlushLogsClosure : public ThreadClosure {

  void do_thread(Thread* thread) override {
    // Flushes deferred card marks, so must precede concatenating logs.
    BarrierSet::barrier_set()->make_parsable((JavaThread*)thread);
    // Retire TLABs.
    if (UseTLAB) { thread->tlab().retire(&_tlab_stats); }

      // Concatenate logs.
      G1DirtyCardQueueSet& qset = G1BarrierSet::dirty_card_queue_set();
      _refinement_stats += qset.concatenate_log_and_stats(thread);

      // Flush region pin count cache.
      G1ThreadLocalData::pin_count_cache(thread).flush();
  }
}

void G1YoungCollector::calculate_collection_set(G1EvacInfo* evacuation_info, double target_pause_time_ms) {
  allocator()->release_mutator_alloc_regions();

  collection_set()->finalize_initial_collection_set(target_pause_time_ms, survivor_regions());

  concurrent_mark()->verify_no_collection_set_oops(); //本节不涉及

  if (G1HeapRegionPrinter::is_active()) { //打印 cset
    collection_set()->iterate(&cl);
    collection_set()->iterate_optional(&cl);
  }
}

void G1Allocator::release_mutator_alloc_regions() {
  for (uint i = 0; i < _num_alloc_regions; i++) { 
    mutator_alloc_region(i)->release(); }
}

//MutatorAllocRegion::release()->G1AllocRegion::release()
//->G1AllocRegion::retire->G1AllocRegion::retire_internal
//->MutatorAllocRegion::retire_region->

void G1CollectedHeap::retire_mutator_alloc_region(G1HeapRegion* alloc_region,
                                                  size_t allocated_bytes) {
  collection_set()->add_eden_region(alloc_region); //加入到 cset
  increase_used(allocated_bytes);
  _eden.add_used_bytes(allocated_bytes);
}

inline HeapWord* G1Allocator::attempt_allocation_locked(size_t word_size) {
  uint node_index = current_node_index();
  return  mutator_alloc_region(node_index)->attempt_allocation_locked(word_size);
}

//G1AllocRegion::attempt_allocation_locked->attempt_allocation_using_new_region
// -> retire -> retire_internal -> MutatorAllocRegion::retire_region
//-> G1CollectedHeap::retire_mutator_alloc_region
inline HeapWord* G1AllocRegion::attempt_allocation_using_new_region(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size) {
  retire(true /* fill_up */);
  //omit
}

//post_evacuate_collection_set->start_new_collection_set
//->transfer_survivors_to_cset->add_survivor_regions

void G1Policy::transfer_survivors_to_cset(const G1SurvivorRegions* survivors) {
  start_adding_survivor_regions();

  for (GrowableArrayIterator<G1HeapRegion*> it = survivors->regions()->begin(); it != survivors->regions()->end(); ++it) {
    G1HeapRegion* curr = *it;
    _collection_set->add_survivor_regions(curr);
  }
  stop_adding_survivor_regions();
}

HeapWord* G1Allocator::par_allocate_during_gc(G1HeapRegionAttr dest, size_t min_word_size, size_t desired_word_size, size_t* actual_word_size, uint node_index) {
  switch (dest.type()) {
    case G1HeapRegionAttr::Young:
      return survivor_attempt_allocation(min_word_size, desired_word_size, actual_word_size, node_index);
    case G1HeapRegionAttr::Old:
      return old_attempt_allocation(min_word_size, desired_word_size, actual_word_size);
      //omit
  }
}
//survivor_attempt_allocation-> attempt_allocation_using_new_region
//-> attempt_allocation_using_new_region -> retire
//->G1AllocRegion::retire_internal->G1GCAllocRegion::retire_region
//->G1CollectedHeap::retire_gc_alloc_region
void G1CollectedHeap::retire_gc_alloc_region(G1HeapRegion* alloc_region, size_t allocated_bytes, G1HeapRegionAttr dest) {
  _bytes_used_during_gc += allocated_bytes;
  if (dest.is_old()) { old_set_add(alloc_region); } 
  else {
    _survivor.add_used_bytes(allocated_bytes); //将 region 加入到 _survivor
  }
  // 并发标记会使用到
  if (during_im && allocated_bytes > 0) { _cm->add_root_region(alloc_region); }
}

//post_evacuate_collection_set-> release_gc_alloc_regions

// All old gen collection set candidate regions.
G1CollectionSetCandidates _candidates;

class G1CollectionSetCandidates : public CHeapObj<mtGC> {
  G1CollectionCandidateList _marking_regions;  // Set of regions selected by concurrent marking.
  G1CollectionCandidateList _retained_regions; // Set of regions selected from evacuation failed regions.
}

void G1CollectionSet::finalize_old_part(double time_remaining_ms) {
    G1CollectionCandidateRegionList initial_old_regions;
    G1CollectionCandidateRegionList pinned_marking_regions;
    G1CollectionCandidateRegionList pinned_retained_regions;

    if (collector_state()->in_mixed_phase()) {
      time_remaining_ms = select_candidates_from_marking(time_remaining_ms, &initial_old_regions, &pinned_marking_regions); } else { }

    select_candidates_from_retained(time_remaining_ms, &initial_old_regions, &pinned_retained_regions)

//->pre_evacuate_collection_set -> finalize_initial_collection_set 
//->finalize_old_part-> move_candidates_to_collection_set -> add_old_region

// Move initially selected old regions to collection set directly.
move_candidates_to_collection_set(&initial_old_regions);

if (collector_state()->in_concurrent_start_gc()) {
    concurrent_mark()->pre_concurrent_start(_gc_cause);
}

ref_processor_stw()->start_discovery(false /* always_clear */);

_evac_failure_regions.pre_collection(_g1h->max_reserved_regions());

// Initialize the GC alloc regions.
allocator()->init_gc_alloc_regions(evacuation_info);

rem_set()->prepare_for_scan_heap_roots();
_g1h->prepare_group_cardsets_for_scan();

void work(uint worker_id) {
  G1PrepareRegionsClosure cl(_g1h, this);
  _g1h->heap_region_par_iterate_from_worker_offset(&cl, &_claimer, worker_id);
}