Humongous Object, Mixed GC Trigger

// g1CollectedHeap.cpp 예시 (의사 코드)
HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size) {
    // 1. 몇 개의 리전이 필요한지 계산
    uint num_regions = humongous_obj_allocate_find_first(num_regions, word_size);
    // 2. 연속된 리전 확보 시도
    // 3. 해당 리전들을 Humongous 타입으로 설정
}

// 리전 타입을 정의하는 부분에서 Humongous를 별도로 구분합니다.
bool is_humongous() const { return _type >= HumongousMask; }
bool is_starts_humongous() const { return _type == StartsHumongous; }
bool is_continues_humongous() const { return _type == ContinuesHumongous; }

void G1CollectedHeap::eagerly_reclaim_humongous_regions() {
  assert_at_safepoint_on_vm_thread();

  // 1. Eager Reclaim 옵션이 꺼져있거나 후보가 없으면 바로 리턴
  if (!G1EagerReclaimHumongousObjects ||
      _humongous_reclaim_candidates.is_empty()) {
    return;
  }

  G1TraceEagerReclaimHumongousObjects tlog(_humongous_reclaim_candidates.length());

  // 2. 클로저(Closure)를 생성하여 힙 리전을 순회하며 조건에 맞는 객체를 찾음
  G1EagerlyReclaimHumongousObjectsClosure cl;
  heap_region_iterate(&cl);

  // 3. 통계 업데이트
  tlog.set_reclaimed(cl.reclaimed_count());
}

bool humongous_region_is_candidate(G1HeapRegion* region) const {
      assert(region->is_starts_humongous(), "Must start a humongous object");

      oop obj = cast_to_oop(region->bottom());

      // Dead objects cannot be eager reclaim candidates. Due to class
      // unloading it is unsafe to query their classes so we return early.
      if (_g1h->is_obj_dead(obj, region)) {
        return false;
      }

      // If we do not have a complete remembered set for the region, then we can
      // not be sure that we have all references to it.
      if (!region->rem_set()->is_complete()) {
        return false;
      }
      // We also cannot collect the humongous object if it is pinned.
      if (region->has_pinned_objects()) {
        return false;
      }
      // Candidate selection must satisfy the following constraints
      // while concurrent marking is in progress:
      //
      // * In order to maintain SATB invariants, an object must not be
      // reclaimed if it was allocated before the start of marking and
      // has not had its references scanned.  Such an object must have
      // its references (including type metadata) scanned to ensure no
      // live objects are missed by the marking process.  Objects
      // allocated after the start of concurrent marking don't need to
      // be scanned.
      //
      // * An object must not be reclaimed if it is on the concurrent
      // mark stack.  Objects allocated after the start of concurrent
      // marking are never pushed on the mark stack.
      //
      // Nominating only objects allocated after the start of concurrent
      // marking is sufficient to meet both constraints.  This may miss
      // some objects that satisfy the constraints, but the marking data
      // structures don't support efficiently performing the needed
      // additional tests or scrubbing of the mark stack.
      //
      // We handle humongous objects specially, because frequent allocation and
      // dropping of large binary blobs is an important use case for eager reclaim,
      // and this special handling increases needed headroom.
      // It also helps with G1 allocating humongous objects as old generation
      // objects although they might also die quite quickly.
      //
      // TypeArray objects are allowed to be reclaimed even if allocated before
      // the start of concurrent mark.  For this we rely on mark stack insertion
      // to exclude is_typeArray() objects, preventing reclaiming an object
      // that is in the mark stack.  We also rely on the metadata for
      // such objects to be built-in and so ensured to be kept live.
      //
      // Non-typeArrays that were allocated before marking are excluded from
      // eager reclaim during marking.  One issue is the problem described
      // above with scrubbing the mark stack, but there is also a problem
      // causing these humongous objects being collected incorrectly:
      //
      // E.g. if the mutator is running, we may have objects o1 and o2 in the same
      // region, where o1 has already been scanned and o2 is only reachable by
      // the candidate object h, which is humongous.
      //
      // If the mutator read the reference to o2 from h and installed it into o1,
      // no remembered set entry would be created for keeping alive o2, as o1 and
      // o2 are in the same region.  Object h might be reclaimed by the next
      // garbage collection. o1 still has the reference to o2, but since o1 had
      // already been scanned we do not detect o2 to be still live and reclaim it.
      //
      // There is another minor problem with non-typeArray regions being the source
      // of remembered set entries in other region's remembered sets.  There are
      // two cases: first, the remembered set entry is in a Free region after reclaim.
      // We handle this case by ignoring these cards during merging the remembered
      // sets.
      //
      // Second, there may be cases where eagerly reclaimed regions were already
      // reallocated.  This may cause scanning of these outdated remembered set
      // entries, containing some objects. But apart from extra work this does
      // not cause correctness issues.
      // There is no difference between scanning cards covering an effectively
      // dead humongous object vs. some other objects in reallocated regions.
      //
      // TAMSes are only reset after completing the entire mark cycle, during
      // bitmap clearing. It is worth to not wait until then, and allow reclamation
      // outside of actual (concurrent) SATB marking.
      // This also applies to the concurrent start pause - we only set
      // mark_in_progress() at the end of that GC: no mutator is running that can
      // sneakily install a new reference to the potentially reclaimed humongous
      // object.
      // During the concurrent start pause the situation described above where we
      // miss a reference can not happen. No mutator is modifying the object
      // graph to install such an overlooked reference.
      //
      // After the pause, having reclaimed h, obviously the mutator can't fetch
      // the reference from h any more.
      if (!obj->is_typeArray()) {
        // All regions that were allocated before marking have a TAMS != bottom.
        bool allocated_before_mark_start = region->bottom() != _g1h->concurrent_mark()->top_at_mark_start(region);
        bool mark_in_progress = _g1h->collector_state()->mark_in_progress();

        if (allocated_before_mark_start && mark_in_progress) {
          return false;
        }
      }
      return _g1h->is_potential_eager_reclaim_candidate(region);
    }

virtual bool do_heap_region(G1HeapRegion* hr) {
      // First prepare the region for scanning
      _g1h->rem_set()->prepare_region_for_scan(hr);

      // Now check if region is a humongous candidate
      if (!hr->is_starts_humongous()) {
        _g1h->update_region_attr(hr);
        return false;
      }

      uint index = hr->hrm_index();
      if (humongous_region_is_candidate(hr)) {
        _g1h->register_humongous_candidate_region_with_region_attr(index);
        _worker_humongous_candidates++;
        // We will later handle the remembered sets of these regions.
      } else {
        _g1h->update_region_attr(hr);
      }

      // Sample card set sizes for humongous regions before GC: this makes the policy
      // to give back memory to the OS keep the most recent amount of memory for these regions.
      _humongous_card_set_stats.add(hr->rem_set()->card_set_memory_stats());

      log_debug(gc, humongous)("Humongous region %u (object size %zu @ " PTR_FORMAT ") remset %zu code roots %zu "
                               "marked %d pinned count %zu reclaim candidate %d type %s",
                               index,
                               cast_to_oop(hr->bottom())->size() * HeapWordSize,
                               p2i(hr->bottom()),
                               hr->rem_set()->occupied(),
                               hr->rem_set()->code_roots_list_length(),
                               _g1h->concurrent_mark()->mark_bitmap()->is_marked(hr->bottom()),
                               hr->pinned_count(),
                               _g1h->is_humongous_reclaim_candidate(index),
                               cast_to_oop(hr->bottom())->is_typeArray() ? "tA"
                                                                         : (cast_to_oop(hr->bottom())->is_objArray() ? "oA" : "ob")
                              );
      _worker_humongous_total++;

      return false;
    }
}

 if (humongous_region_is_candidate(hr)) {
        _g1h->register_humongous_candidate_region_with_region_attr(index);
        _worker_humongous_candidates++;
        // We will later handle the remembered sets of these regions.
      } else {
        _g1h->update_region_attr(hr);
      }