G1 重要概念

//src/hotspot/share/gc/g1/heapRegionBounds.hpp
static const size_t MIN_REGION_SIZE = 1024 * 1024; //1M
static const size_t MAX_ERGONOMICS_SIZE = 32 * 1024 * 1024; // 32M，G1 自动调节的最大值
static const size_t MAX_REGION_SIZE = 512 * 1024 * 1024; //512 Mb

// HeapRegion -> HeapRegionRemSet* _rem_set -> OtherRegionsTable _other_regions
class OtherRegionsTable VALUE_OBJ_CLASS_SPEC {
  BitMap      _coarse_map; 
  PerRegionTable** _fine_grain_regions;
  SparsePRT   _sparse_table;
}

class SparsePRTEntry: public CHeapObj<mtGC> {
  typedef uint16_t card_elem_t;
  card_elem_t _cards[card_array_alignment];
}

var exist  = find_in(_coarse_map, region_idx, card_idx);
if(exist) return;
 
var exist  = find_in(_fine_grain_regions,region_idx, card_idx);
if(exist) return;
 
var res = add_card_to(_sparse_table,region_idx, card_idx);
if(res == SparsePRT::added) return ;
 
add_card_to_fine_grain_regions_and_transfer(_fine_grain_regions,_sparse_table ,region_idx, card_idx)

//G1HeapRegion rem_set  -> G1HeapRegionRemSet _card_set
class G1CardSet : public CHeapObj<mtGCCardSet> {
    G1CardSetHashTable* _table;
}

class G1CardSetHashTable : public CHeapObj<mtGCCardSet> {
  CardSetHash _table;
  CHTScanTask _table_scanner;
}
using CardSetHash = ConcurrentHashTable<G1CardSetHashTableConfig, mtGCCardSet>;

G1CardSetHashTableValue value(region_idx, G1CardSetInlinePtr());

bool G1CardSet::coarsen_container(ContainerPtr volatile* container_addr, ContainerPtr cur_container,uint card_in_region, bool within_howl) {
  ContainerPtr new_container = nullptr;
  switch (container_type(cur_container)) {
    case ContainerArrayOfCards: {
      //如果当前容器被 ContainerHowl 包含，则升级成 ContainerBitMap，
      //反之则升级成 ContainerHowl
      new_container = create_coarsened_array_of_cards(card_in_region, within_howl);
      break;
    }
    case ContainerBitMap: {
      new_container = FullCardSet;
      break;
    }
    case ContainerInlinePtr: {
      //升级为 ContainerArrayOfCards
      uint8_t* data = allocate_mem_object(ContainerArrayOfCards);
      break;
    }
    case ContainerHowl: {
      new_container = FullCardSet; // anything will do at this point.
      break;
    }
// omit
  }

// MSB                                                 LSB
// +------+         +---------------+--------------+-----+
// |unused|   ...   |  card_index1  | card_index0  |SSS00|
// +------+         +---------------+--------------+-----+

inline void G1ConcurrentRefineOopClosure::do_oop_work(T* p) {
  T o = RawAccess<MO_RELAXED>::oop_load(p);
  oop obj = CompressedOops::decode_not_null(o);  //目标对象  
   //目标对象的记忆集
  G1HeapRegionRemSet* to_rem_set = _g1h->heap_region_containing(obj)->rem_set();
  
  if (to_rem_set->is_tracked()) {//将源对象添加到目标对象的记忆集中
    to_rem_set->add_reference(p, _worker_id);
  }
}

 //  垃圾收集遍历记忆集传入 at_safepoint 为 true
void G1CardSet::iterate_containers(ContainerPtrClosure* cl, bool at_safepoint) {
  //omit 
    _table->iterate_safepoint(do_value);
}

template <typename SCAN_FUNC>
  void iterate_safepoint(SCAN_FUNC& scan_f) {
    _table_scanner.do_safepoint_scan(scan_f);
  }

void reset_table_scanner(uint claim_size) {
    _table_scanner.set(&_table, claim_size);
  }

class G1CollectedHeap : public CollectedHeap {
    G1CardSet _young_regions_cardset;
}
//堆初始化的时候创建
_young_regions_cardset(card_set_config(), &_young_regions_cardset_mm)

//G1CollectedHeap::set_region_short_lived_locked-> G1HeapRegion::install_group_cardset

void install_group_cardset(G1CardSet* group_cardset) {
  _card_set = group_cardset; // 堆中全局的 `G1CardSet` 赋值给新的 region。
}

jint G1CollectedHeap::initialize() {
     G1CardTable* ct = new G1CardTable(heap_rs.region());
     _card_table->initialize(cardtable_storage);
 }

class CardTable{
  typedef uint8_t CardValue;
  size_t          _byte_map_size;    // in bytes
  CardValue*      _byte_map;         // the card marking array
  CardValue*      _byte_map_base
}

  CardValue* byte_for(const void* p) const {
    CardValue* result = &_byte_map_base[uintptr_t(p) >> _card_shift];
    return result;

  CardValue* byte_for(const void* p) const {
    int idx  = uintptr_t(p) >> _card_shift - (uintptr_t(low_bound) >> _card_shift);
    CardValue* result = &_byte_map[idx];
    return result;

typedef uint64_t GCThreadLocalData[43]; // 344 bytes

class Thread{
  GCThreadLocalData _gc_data;
}

static G1ThreadLocalData* data(Thread* thread) {
  return thread->gc_data<G1ThreadLocalData>();
}

class G1ThreadLocalData {
  SATBMarkQueue _satb_mark_queue;
  G1DirtyCardQueue _dirty_card_queue;
  G1RegionPinCache _pin_cache;
}

class PtrQueue {
  // The (byte) index at which an object was last enqueued.  Starts at
  // capacity (in bytes) (indicating an empty buffer) and goes towards zero
  size_t _index;
  void** _buf;
}

void G1BarrierSet::write_ref_field_post_slow(volatile CardValue* byte) {
  //omit
  G1DirtyCardQueue& queue = G1ThreadLocalData::dirty_card_queue(thr);
  G1BarrierSet::dirty_card_queue_set().enqueue(queue, byte);
}

void G1DirtyCardQueueSet::enqueue(G1DirtyCardQueue& queue, volatile CardValue* card_ptr) {
  CardValue* value = const_cast<CardValue*>(card_ptr);
  if (!try_enqueue(queue, value)) {
    handle_zero_index(queue);
    retry_enqueue(queue, value);
  }
}

//handle_zero_index -> handle_completed_buffer 
enqueue_completed_buffer(new_node); //加入到全局队列中


//refine_completed_buffer_concurrently() -> refine_buffer() -> 
//refine() -> refine_cleaned_cards() -> refine_card_concurrently()
template <class T>
inline void G1ConcurrentRefineOopClosure::do_oop_work(T* p) {
  T o = RawAccess<MO_RELAXED>::oop_load(p);

  if (CompressedOops::is_null(o)) { return; }

  oop obj = CompressedOops::decode_not_null(o);

  if (G1HeapRegion::is_in_same_region(p, obj)) { return; }

  G1HeapRegionRemSet* to_rem_set = _g1h->heap_region_containing(obj)->rem_set();
  if (to_rem_set->is_tracked()) {
    to_rem_set->add_reference(p, _worker_id);
  }
}

// jdk/src/hotspot/share/interpreter/zero/bytecodeInterpreter.cpp
// obj是接收者对象，field_offset
 obj->obj_field_put(field_offset, val);

//-> obj->obj_field_put(field_offset, val);
//-> oopDesc::obj_field_put(int offset, oop value) 
//-> HeapAccess<>::oop_store_at(as_oop(), offset, value);
//-> oop_store_at(oop base, ptrdiff_t offset, T value)
//-> store_at(oop base, ptrdiff_t offset, T value)
//
//->  template <DecoratorSet decorators, typename T>
//    inline static typename EnableIf<
//    !HasDecorator<decorators, AS_RAW>::value>::type
//    store_at(oop base, ptrdiff_t offset, T value)
//
//-> template <DecoratorSet decorators, typename T>
//   struct RuntimeDispatch<decorators, T, BARRIER_STORE_AT>: AllStatic {
//    typedef typename AccessFunction<decorators, T, BARRIER_STORE_AT>::type func_t;
//    static func_t _store_at_func;
//    static inline void store_at(oop base, ptrdiff_t offset, T value) {
//     _store_at_func(base, offset, value);
//   }
//  }
//
RuntimeDispatch<decorators, T, BARRIER_STORE_AT>::_store_at_func = &store_at_init;

RuntimeDispatch<decorators, T, BARRIER_STORE_AT>::_store_at_func = &store_at_init;

//-> void RuntimeDispatch<decorators, T, BARRIER_STORE_AT>::store_at_init(oop base, ptrdiff_t offset, T value)
// -> BarrierResolver<decorators, func_t, BARRIER_STORE_AT>::resolve_barrier()
//->  resolve_barrier_rt()
//-> resolve_barrier_gc()

return PostRuntimeDispatch<typename BarrierSet::GetType<BarrierSet::bs_name>::type::AccessBarrier<ds>, barrier_type, ds>::oop_access_barrier; 

//在 G1 中返回的是
//PostRuntimeDispatch<G1BarrierSet::AccessBarrier<ds>,BARRIER_STORE_AT, ds>::oop_access_barrier

  // Callbacks for runtime accesses.
template <DecoratorSet decorators, typename BarrierSetT = G1BarrierSet>
class AccessBarrier: public ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT> {
    typedef BarrierSet::AccessBarrier<decorators, BarrierSetT> Raw;
}

template <class GCBarrierType, DecoratorSet decorators>
struct PostRuntimeDispatch<GCBarrierType, BARRIER_STORE_AT, decorators>: public AllStatic {
  static void oop_access_barrier(oop base, ptrdiff_t offset, oop value) {
    GCBarrierType::oop_store_in_heap_at(base, offset, value);
  }
}

template <DecoratorSet decorators, typename BarrierSetT>
class AccessBarrier: public BarrierSet::AccessBarrier<decorators, BarrierSetT> {
  static void oop_store_in_heap_at(oop base, ptrdiff_t offset, oop value) {
    oop_store_in_heap(AccessInternal::oop_field_addr<decorators>(base, offset), value);
  }
}

template <DecoratorSet decorators, typename BarrierSetT>
template <typename T>
inline void ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>::
oop_store_in_heap(T* addr, oop value) {
  BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set());
  bs->template write_ref_field_pre<decorators>(addr); //此时 addr 指向的还是旧对象
  Raw::oop_store(addr, value);
  bs->template write_ref_field_post<decorators>(addr);//此时 addr 指向的还是新对象
}

template <DecoratorSet decorators, typename T>
inline void G1BarrierSet::write_ref_field_post(T* field) {
  volatile CardValue* byte = _card_table->byte_for(field);
  if (*byte != G1CardTable::g1_young_card_val()) {
    write_ref_field_post_slow(byte);
  }
}

//src/hotspot/share/gc/g1/g1YoungCollector.cpp#update_young_gc_name
snprintf(_young_gc_name_data, MaxYoungGCNameLength, "Pause Young (%s) (%s)%s",
         G1GCPauseTypeHelper::to_string(_pause_type), GCCause::to_string(_pause_cause),
         evacuation_failed_string)

enum class G1GCPauseType : uint {
  YoungGC, //Normal
  LastYoungGC,//Prepare Mixed
  ConcurrentStartMarkGC,//Concurrent Start
  ConcurrentStartUndoGC, //Concurrent Start
  Cleanup, //Cleanup
  Remark, //Remark
  MixedGC, //Mxed
  FullGC //Full
};