目录
2、allocate / par_allocate / expand_and_allocate /allocation_limit_reached
4、save_marks / no_allocs_since_save_marks / oop_since_save_marks_iterate
5、space_iterate / oop_iterate / safe_object_iterate / object_iterate / younger_refs_iterate
8、should_collect / should_concurrent_collect / is_too_full / collect
9、compute_new_size / compute_new_size_free_list
本篇继续上一篇《Hotspot 垃圾回收之ConcurrentMarkSweepGeneration（二） 源码解析》讲解ConcurrentMarkSweepGeneration的其他关键方法的实现。
1、expand / shrink
这两个方法用于老年代的扩容和缩容，底层都是基于VirtualSpace，执行成功后再重置BlockOffsetSharedArray，重置BarrierSet，重置end属性，其实现如下：
bool ConcurrentMarkSweepGeneration::expand(size_t bytes, size_t expand_bytes) {
//底层实现依赖于子类的grow_by和grow_to_reserved方法
return CardGeneration::expand(bytes, expand_bytes);
}
void ConcurrentMarkSweepGeneration::expand(size_t bytes, size_t expand_bytes,
CMSExpansionCause::Cause cause)
{
bool success = expand(bytes, expand_bytes);
if (success) {
//记录扩展的原因，shouldConcurrentCollect()方法使用
set_expansion_cause(cause);
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("Expanded CMS gen for %s",
CMSExpansionCause::to_string(cause));
}
}
}
void set_expansion_cause(CMSExpansionCause::Cause v) { _expansion_cause = v;}
bool ConcurrentMarkSweepGeneration::grow_by(size_t bytes) {
//校验获取了Heap_lock锁
assert_locked_or_safepoint(Heap_lock);
//通过VirtualSpace扩容，即新申请指定大小的内存
bool result = _virtual_space.expand_by(bytes);
if (result) {
//申请成功，获取当前扩容后的内存容量
size_t new_word_size =
heap_word_size(_virtual_space.committed_size());
MemRegion mr(_cmsSpace->bottom(), new_word_size);
//重置bts对应的内存区域
_bts->resize(new_word_size); // resize the block offset shared array
//重置bs对应的内存区域
Universe::heap()->barrier_set()->resize_covered_region(mr);
//校验获取了freelistLock，即应该是填充FreeList时导致的扩容
_cmsSpace->assert_locked(freelistLock());
//重置end
_cmsSpace->set_end((HeapWord*)_virtual_space.high());
if (UsePerfData) {
//更新计数器
_space_counters->update_capacity();
_gen_counters->update_all();
}
if (Verbose && PrintGC) {
size_t new_mem_size = _virtual_space.committed_size();
size_t old_mem_size = new_mem_size - bytes;
gclog_or_tty->print_cr("Expanding %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K",
name(), old_mem_size/K, bytes/K, new_mem_size/K);
}
}
return result;
}
bool ConcurrentMarkSweepGeneration::grow_to_reserved() {
assert_locked_or_safepoint(Heap_lock);
bool success = true;
//获取剩余未分配内存的空间
const size_t remaining_bytes = _virtual_space.uncommitted_size();
if (remaining_bytes > 0) {
//将剩余空间一次扩容
success = grow_by(remaining_bytes);
}
return success;
}
Mutex* ConcurrentMarkSweepGeneration::freelistLock() const {
return cmsSpace()->freelistLock();
}
void ConcurrentMarkSweepGeneration::shrink_by(size_t bytes) {
assert_locked_or_safepoint(ExpandHeap_lock);
//通过VirtualSpace缩容
_virtual_space.shrink_by(bytes);
//重置end
_cmsSpace->set_end((HeapWord*) _virtual_space.high());
size_t new_word_size = heap_word_size(_cmsSpace->capacity());
//重置bts
_bts->resize(new_word_size);
MemRegion mr(_cmsSpace->bottom(), new_word_size);
//重置bs
Universe::heap()->barrier_set()->resize_covered_region(mr);
if (Verbose && PrintGC) {
size_t new_mem_size = _virtual_space.committed_size();
size_t old_mem_size = new_mem_size + bytes;
gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K to " SIZE_FORMAT "K",
name(), old_mem_size/K, new_mem_size/K);
}
}
void ConcurrentMarkSweepGeneration::shrink(size_t bytes) {
assert_locked_or_safepoint(Heap_lock);
//内存对齐
size_t size = ReservedSpace::page_align_size_down(bytes);
//只有执行过压缩，所有空闲空间都集中中尾部才能缩容
if (size > 0 && did_compact()) {
shrink_by(size);
}
}
bool did_compact() { return _did_compact; }其调用链如下：
2、allocate / par_allocate / expand_and_allocate /allocation_limit_reached
allocate方法会获取freelistLock锁，然后从cmsSpace中分配指定大小的内存，如果此时后台GC进入Marking环节还需要将分配的内存地址标记成存活对象，避免被垃圾回收给清理掉了；因为allocate方法需要获取全局唯一的freelistLock锁所以也适用于并发环境，par_allocate的实现就是调用allocate方法；expand_and_allocate是当allocate返回NULL，即内存分配失败后调用的，会先扩容，再执行与allocate相同的内存分配逻辑。allocation_limit_reached方法时iCMS模式下年轻代通知老年代内存分配达到了soft_end，该方法返回一个新的soft_end地址，非iCMS模式下永远返回NULL。其实现如下：
HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size,
bool tlab) {
//通知CMS Thread让出CPU使用权限
CMSSynchronousYieldRequest yr;
//获取freelistLock，从CompactibleFreeListSpace中分配内存都需要先获取该锁
MutexLockerEx x(freelistLock(),
Mutex::_no_safepoint_check_flag);
return have_lock_and_allocate(size, tlab);
}
HeapWord* ConcurrentMarkSweepGeneration::have_lock_and_allocate(size_t size,
bool tlab /* ignored */) {
assert_lock_strong(freelistLock());
//作内存对齐
size_t adjustedSize = CompactibleFreeListSpace::adjustObjectSize(size);
//从cmsSpace中分配指定大小的内存块
HeapWord* res = cmsSpace()->allocate(adjustedSize);
if (res != NULL) {
//校验这是一个空闲内存块
assert(oop(res)->klass_or_null() == NULL, "Object should be uninitialized here.");
assert(!((FreeChunk*)res)->is_free(), "Error, block will look free but show wrong size");
//如果GC进入Marking环节了，则将该地址标记成存活对象，避免被清理掉
collector()->direct_allocated(res, adjustedSize);
//增加_direct_allocated_words计数器
_direct_allocated_words += adjustedSize;
}
return res;
}
void CMSCollector::direct_allocated(HeapWord* start, size_t size) {
assert(_markBitMap.covers(start, size), "Out of bounds");
//已经进入到标记清理环节，此时分配的地址start可能已经被处理过了，可能会被当做非存活对象给清理掉
//所以需要将该地址打标成存活对象
if (_collectorState >= Marking) {
//获取BitMap的锁
MutexLockerEx y(_markBitMap.lock(),
Mutex::_no_safepoint_check_flag);
_markBitMap.mark(start); //标记这个对象是存活的
_markBitMap.mark(start + 1); // 标记这个对象未初始化
_markBitMap.mark(start + size - 1); //标记这个对象的结束地址，这样marking, precleaning or sweeping等处理时会跳过该对象
}
//校验oop未初始化
assert(oop(start)->klass_or_null() == NULL, "_klass should be NULL");
}
//因为allocate方法执行过程中必须要获取全局唯一的freelistLock锁，所以也完全适用于并发环境下内存分配
HeapWord* par_allocate(size_t size, bool tlab) {
return allocate(size, tlab);
}
HeapWord*
ConcurrentMarkSweepGeneration::expand_and_allocate(size_t word_size,
bool tlab,
bool parallel) {
CMSSynchronousYieldRequest yr;
assert(!tlab, "Can't deal with TLAB allocation");
MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
//先扩展指定大小的内存，MinHeapDeltaBytes表示堆内存扩容或者缩容的最小内存，默认是128k，单位是字节
expand(word_size*HeapWordSize, MinHeapDeltaBytes,
CMSExpansionCause::_satisfy_allocation);
//GCExpandToAllocateDelayMillis表示在内存扩展和内存分配动作之间的停顿，默认是0
if (GCExpandToAllocateDelayMillis > 0) {
os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
}
return have_lock_and_allocate(word_size, tlab);
}
HeapWord*
ConcurrentMarkSweepGeneration::allocation_limit_reached(Space* space,
HeapWord* top,
size_t word_sz)
{
return collector()->allocation_limit_reached(space, top, word_sz);
}
HeapWord*
CMSCollector::allocation_limit_reached(Space* space, HeapWord* top,
size_t word_size)
{
if (CMSIncrementalMode && _icms_start_limit != space->end()) {
if (top <= _icms_start_limit) {
if (CMSTraceIncrementalMode) {
space->print_on(gclog_or_tty);
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" start limit top=" PTR_FORMAT
", new limit=" PTR_FORMAT
" (" SIZE_FORMAT "%%)",
p2i(top), p2i(_icms_stop_limit),
percent_of_space(space, _icms_stop_limit));
}
ConcurrentMarkSweepThread::start_icms();
assert(top < _icms_stop_limit, "Tautology");
//如果剩余空间足够
if (word_size < pointer_delta(_icms_stop_limit, top)) {
return _icms_stop_limit;
}
// _icms_stop_limit到top之间的空间不够
if (CMSTraceIncrementalMode) {
space->print_on(gclog_or_tty);
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" +stop limit top=" PTR_FORMAT
", new limit=" PTR_FORMAT
" (" SIZE_FORMAT "%%)",
p2i(top), p2i(space->end()),
percent_of_space(space, space->end()));
}
//停止垃圾回收，返回end
ConcurrentMarkSweepThread::stop_icms();
return space->end();
}
//top大于_icms_start_limit
if (top <= _icms_stop_limit) {
if (CMSTraceIncrementalMode) {
space->print_on(gclog_or_tty);
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" stop limit top=" PTR_FORMAT
", new limit=" PTR_FORMAT
" (" SIZE_FORMAT "%%)",
top, space->end(),
percent_of_space(space, space->end()));
}
//停止垃圾收集
ConcurrentMarkSweepThread::stop_icms();
return space->end();
}
if (CMSTraceIncrementalMode) {
space->print_on(gclog_or_tty);
gclog_or_tty->stamp();
gclog_or_tty->print_cr(" end limit top=" PTR_FORMAT
", new limit=" PTR_FORMAT,
top, NULL);
}
}
//CMSIncrementalMode为false，即默认配置下，当前方法永远返回NULL
return NULL;
}其调用链如下：
3、 promote / par_promote / par_promote_alloc_done / promotion_attempt_is_safe / promotion_failure_occurred
promote是在单线程时使用，将对象从年轻代复制到老年代，如果老年代内存不足则尝试扩容，复制成功后需要在_markBitMap和_modUnionTable打标，将复制的对象标记成存活的，已经被扫描过了。注意因为复制过去的对象本身已经完成初始化了，所以不需要将其标记成为初始化的，并且如果对象是一个数组，需要将数组的整个区域而不仅仅是头部地址打标。
par_promote是并行GC时调用，整体逻辑跟promote相同，不过promote分配内存时使用的是当前线程对应的CMSParGCThreadState中的lab，执行promote 跟踪时也是使用当前线程对应的CMSParGCThreadState中的prom，避免多个线程同时从老年代分配内存造成锁竞争，从而提高并行promote的效率；如果当前线程的lab和prom的内存不足了，则同样需要扩容老年代，然后给lab和prom分配内存；另外跟单线程的promote相比，par_promote在复制对象时更加谨慎，不是一次复制完成，而是将对象头，klass和对象数据分开复制，每次复制结束都调用OrderAccess::storestore();在多个CPU间同步；跟单线程的promote一样，复制结束，需要在在_markBitMap和_modUnionTable打标。
par_promote_alloc_done是并行GC线程执行promote结束后调用的，将当前GC线程的lab中的未使用内存归还给老年代。
promotion_attempt_is_safe方法用于判断执行promote是否是安全的，主要判断历史promote的内存和传入的promote的最大内存是否超过当前老年代的可使用最大空间。
promotion_failure_occurred是年轻代执行promote时，出现promote失败通知老年代执行必要的处理，在默认配置下不做任何处理，如果CMSDumpAtPromotionFailure只为true，可以dump当时的老年代内存使用情况。各方法的实现如下：
oop ConcurrentMarkSweepGeneration::promote(oop obj, size_t obj_size) {
assert(obj_size == (size_t)obj->size(), "bad obj_size passed in");
//校验获取freelistLock锁
assert_lock_strong(freelistLock());
//cmsSpace的promote方法就是从cmsSpace分配指定大小的内存，然后将obj拷贝过去
oop res = _cmsSpace->promote(obj, obj_size);
if (res == NULL) {
//res等于NULL说明内存不足导致内存分配失败
//计算需要扩容的大小
size_t s = _cmsSpace->expansionSpaceRequired(obj_size); // HeapWords
//执行扩容
expand(s*HeapWordSize, MinHeapDeltaBytes,
CMSExpansionCause::_satisfy_promotion);
assert(next_gen() == NULL, "assumption, based upon which no attempt "
"is made to pass on a possibly failing "
"promotion to next generation");
//再次执行promote
res = _cmsSpace->promote(obj, obj_size);
}
if (res != NULL) {
//promote成功
assert(obj->is_oop(), "Will dereference klass pointer below");
//执行_markBitMap和_modUnionTable打标
collector()->promoted(false, // Not parallel
(HeapWord*)res, obj->is_objArray(), obj_size);
}
return res;
}
void CMSCollector::promoted(bool par, HeapWord* start,
bool is_obj_array, size_t obj_size) {
assert(_markBitMap.covers(start), "Out of bounds");
if (_collectorState >= Marking) {
//如果GC已经到Marking环节，则需要将start标记成存活的，避免被清理掉
if (par) {
//这里不需要标记对应未初始化，因为该对象是从年轻代复制过来的，已经完成初始化了
_markBitMap.par_mark(start);
} else {
_markBitMap.mark(start);
}
//
assert(SafepointSynchronize::is_at_safepoint(),
"expect promotion only at safepoints");
if (_collectorState < Sweeping) {
//在_modUnionTable中打标，表示被扫描过了
if (is_obj_array) {
//如果是数组，则需要将整个数组对应的内存区域标记成活的，注意数组的结束地址
//需要按照card_size对齐
MemRegion mr(start,
(HeapWord*)round_to((intptr_t)(start + obj_size),
CardTableModRefBS::card_size /* bytes */));
if (par) {
_modUnionTable.par_mark_range(mr);
} else {
_modUnionTable.mark_range(mr);
}
} else { // not an obj array; we can just mark the head
if (par) {
_modUnionTable.par_mark(start);
} else {
_modUnionTable.mark(start);
}
}
}
}
}
oop
ConcurrentMarkSweepGeneration::par_promote(int thread_num,
oop old, markOop m,
size_t word_sz) {
//获取thread_num对应的本地线程缓存
CMSParGCThreadState* ps = _par_gc_thread_states[thread_num];
PromotionInfo* promoInfo = &ps->promo;
if (promoInfo->tracking() && !promoInfo->ensure_spooling_space()) {
//如果开启promote跟踪，但是没有足够的空间，则尝试扩展promoInfo
if (!expand_and_ensure_spooling_space(promoInfo)) {
//扩展失败返回NULL
return NULL;
}
}
assert(promoInfo->has_spooling_space(), "Control point invariant");
//内存对齐
const size_t alloc_sz = CompactibleFreeListSpace::adjustObjectSize(word_sz);
//从LAB中分配内存
HeapWord* obj_ptr = ps->lab.alloc(alloc_sz);
if (obj_ptr == NULL) {
//分配失败，说明内存不足，尝试扩容并重新分配
obj_ptr = expand_and_par_lab_allocate(ps, alloc_sz);
if (obj_ptr == NULL) {
//扩容失败返回NULL
return NULL;
}
}
//从LAB中分配内存成功
oop obj = oop(obj_ptr);
OrderAccess::storestore();
//校验obj未初始化
assert(obj->klass_or_null() == NULL, "Object should be uninitialized here.");
assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size");
HeapWord* old_ptr = (HeapWord*)old;
//复制对象头
obj->set_mark(m);
assert(obj->klass_or_null() == NULL, "Object should be uninitialized here.");
assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size");
OrderAccess::storestore();
if (UseCompressedClassPointers) {
//复制klass_gap
obj->set_klass_gap(old->klass_gap());
}
if (word_sz > (size_t)oopDesc::header_size()) {
//复制对象头以外的数据，对象头就是oopDesc本身占用的空间，不包含Java对象属性
//对象头的数据通过set_mark和set_klass就完成拷贝了
Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(),
obj_ptr + oopDesc::header_size(),
word_sz - oopDesc::header_size());
}
if (promoInfo->tracking()) {
//promote 跟踪
promoInfo->track((PromotedObject*)obj, old->klass());
}
assert(obj->klass_or_null() == NULL, "Object should be uninitialized here.");
assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size");
assert(old->is_oop(), "Will use and dereference old klass ptr below");
OrderAccess::storestore();
//设置klass
obj->set_klass(old->klass());
// We should now be able to calculate the right size for this object
assert(obj->is_oop() && obj->size() == (int)word_sz, "Error, incorrect size computed for promoted object");
//执行_markBitMap和_modUnionTable打标
collector()->promoted(true, // parallel
obj_ptr, old->is_objArray(), word_sz);
return obj;
}
bool ConcurrentMarkSweepGeneration::expand_and_ensure_spooling_space(
PromotionInfo* promo) {
//获取ParGCRareEvent_lock锁
MutexLocker x(ParGCRareEvent_lock);
//计算需要扩容的内存大小
size_t refill_size_bytes = promo->refillSize() * HeapWordSize;
while (true) {
if (promo->ensure_spooling_space()) {
//如果有充足的空间，则返回true
assert(promo->has_spooling_space(),
"Post-condition of successful ensure_spooling_space()");
return true;
}
if (_virtual_space.uncommitted_size() < refill_size_bytes) {
//如果老年代剩余未扩容空间不够了，返回false
return false;
}
//老年代剩余空间足够，执行扩容
expand(refill_size_bytes, MinHeapDeltaBytes,
CMSExpansionCause::_allocate_par_spooling_space);
//GCExpandToAllocateDelayMillis默认为0
if (GCExpandToAllocateDelayMillis > 0) {
os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
}
//进入下一次循环，直到promo由足够空间或者老年代剩余空间不够了
}
}
HeapWord* ConcurrentMarkSweepGeneration::expand_and_par_lab_allocate(CMSParGCThreadState* ps, size_t word_sz) {
HeapWord* res = NULL;
MutexLocker x(ParGCRareEvent_lock);
while (true) {
//尝试分配，分配成功则返回
res = ps->lab.alloc(word_sz);
if (res != NULL) return res;
if (_virtual_space.uncommitted_size() < (word_sz * HeapWordSize)) {
//老年代剩余空间不足，返回NULL
return NULL;
}
//老年代剩余空间充足，执行扩容
expand(word_sz*HeapWordSize, MinHeapDeltaBytes,
CMSExpansionCause::_allocate_par_lab);
if (GCExpandToAllocateDelayMillis > 0) {
os::sleep(Thread::current(), GCExpandToAllocateDelayMillis, false);
}
}
}
static int header_size() { return sizeof(oopDesc)/HeapWordSize; }
void
ConcurrentMarkSweepGeneration::
par_promote_alloc_done(int thread_num) {
CMSParGCThreadState* ps = _par_gc_thread_states[thread_num];
//将指定线程的LAB包含的剩余的未使用的内存归还给老年代
ps->lab.retire(thread_num);
}
bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
size_t available = max_available();
//历史进行promote需要的内存大小
size_t av_promo = (size_t)gc_stats()->avg_promoted()->padded_average();
//如果剩余空间足够promote使用，则返回true
bool res = (available >= av_promo) || (available >= max_promotion_in_bytes);
if (Verbose && PrintGCDetails) {
gclog_or_tty->print_cr(
"CMS: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT "),"
"max_promo(" SIZE_FORMAT ")",
res? "":" not", available, res? ">=":"<",
av_promo, max_promotion_in_bytes);
}
return res;
}
void ConcurrentMarkSweepGeneration::promotion_failure_occurred() {
//CMSDumpAtPromotionFailure表示在promote失败时执行dump，默认为false
if (CMSDumpAtPromotionFailure) {
cmsSpace()->dump_at_safepoint_with_locks(collector(), gclog_or_tty);
}
}
GCStats* gc_stats() const { return _gc_stats; }
//返回当前可供使用的最大空间
size_t ConcurrentMarkSweepGeneration::max_available() const {
return free() + _virtual_space.uncommitted_size();
}
inline size_t ConcurrentMarkSweepGeneration::free() const {
return _cmsSpace->free();
}各方法的调用链如下：
4、save_marks / no_allocs_since_save_marks / oop_since_save_marks_iterate
save_marks用于保存老年代的_saved_mark_word并开启promote 跟踪；no_allocs_since_save_marks判断老年代是否执行了promote；oop_since_save_marks_iterate是宏定义的一组方法，用于遍历promote产生的PromotedObject，包含的方法如下：
其实现如下：
void ConcurrentMarkSweepGeneration::save_marks() {
//设置_saved_mark_word，调用cmsSpace的_promoInfo的startTrackingPromotions方法
cmsSpace()->save_marks();
for (uint i = 0; i < ParallelGCThreads; i++) {
_par_gc_thread_states[i]->promo.startTrackingPromotions();
}
}
//判断是指执行了promote
bool ConcurrentMarkSweepGeneration::no_allocs_since_save_marks() {
return cmsSpace()->no_allocs_since_save_marks();
}
bool CompactibleFreeListSpace::no_allocs_since_save_marks() {
assert(_promoInfo.tracking(), "No preceding save_marks?");
assert(SharedHeap::heap()->n_par_threads() == 0,
"Shouldn't be called if using parallel gc.");
return _promoInfo.noPromotions();
}
#define CMS_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \
\
void ConcurrentMarkSweepGeneration:: \
oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \
cl->set_generation(this); \
//调用cmsSpace对应的遍历方法
cmsSpace()->oop_since_save_marks_iterate##nv_suffix(cl); \
cl->reset_generation(); \
//重置_saved_mark_word
save_marks(); \
}
ALL_SINCE_SAVE_MARKS_CLOSURES(CMS_SINCE_SAVE_MARKS_DEFN)
其调用链如下：
5、space_iterate / oop_iterate / safe_object_iterate / object_iterate / younger_refs_iterate
space_iterate是父类Generation的block_size，block_start，oop_iterate等方法使用的，用来遍历Generation子类包含的多个Space实例；后面三个方法都是借助父类Generation的方法实现的，不过多了一步获取freelistLock锁的动作，其实现如下：
void ConcurrentMarkSweepGeneration::space_iterate(SpaceClosure* blk, bool usedOnly) {
//老年代只有一个Space
blk->do_space(_cmsSpace);
}
void
ConcurrentMarkSweepGeneration::oop_iterate(ExtendedOopClosure* cl) {
if (freelistLock()->owned_by_self()) {
Generation::oop_iterate(cl);
} else {
MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
Generation::oop_iterate(cl);
}
}
void
ConcurrentMarkSweepGeneration::object_iterate(ObjectClosure* cl) {
if (freelistLock()->owned_by_self()) {
Generation::object_iterate(cl);
} else {
MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
Generation::object_iterate(cl);
}
}
void
ConcurrentMarkSweepGeneration::safe_object_iterate(ObjectClosure* cl) {
if (freelistLock()->owned_by_self()) {
Generation::safe_object_iterate(cl);
} else {
MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
Generation::safe_object_iterate(cl);
}
}
void
ConcurrentMarkSweepGeneration::younger_refs_iterate(OopsInGenClosure* cl) {
cl->set_generation(this);
//调用父类Genaration的方法，底层调用CardTableRS::younger_refs_in_space_iterate方法完成遍历
younger_refs_in_space_iterate(_cmsSpace, cl);
cl->reset_generation();
}
void Generation::younger_refs_in_space_iterate(Space* sp,
OopsInGenClosure* cl) {
GenRemSet* rs = SharedHeap::heap()->rem_set();
rs->younger_refs_in_space_iterate(sp, cl);
}6、sample_eden_chunk
sample_eden_chunk用来记录年轻代eden区的top属性的值，即已分配内存的边界，年轻代每次通过allocate方法成功分配内存后就会调用该方法。其实现如下：
void sample_eden_chunk() {
return collector()->sample_eden_chunk();
}
void CMSCollector::sample_eden_chunk() {
//CMSEdenChunksRecordAlways默认为true
if (CMSEdenChunksRecordAlways && _eden_chunk_array != NULL) {
//获取锁_eden_chunk_lock
if (_eden_chunk_lock->try_lock()) {
//记录eden区top属性的值
_eden_chunk_array[_eden_chunk_index] = *_top_addr;
//校验top属性的值小于等于end属性的值
assert(_eden_chunk_array[_eden_chunk_index] <= *_end_addr,
"Unexpected state of Eden");
//CMSSamplingGrain标识CMS Samples之间的最小距离，默认为16k
//如果_eden_chunk_index等于0即第一次调用或者当前_eden_chunk_index的值比上一个大CMSSamplingGrain
//从而在保证准确性的前提下减少_eden_chunk_array的元素个数
if (_eden_chunk_index == 0 ||
((_eden_chunk_array[_eden_chunk_index] > _eden_chunk_array[_eden_chunk_index-1]) &&
(pointer_delta(_eden_chunk_array[_eden_chunk_index],
_eden_chunk_array[_eden_chunk_index-1]) >= CMSSamplingGrain))) {
//_eden_chunk_index加1，即提交一个sample
_eden_chunk_index++; // commit sample
}
//解锁
_eden_chunk_lock->unlock();
}
}
}
其调用链如下：
7、gc_prologue / gc_epilogue
gc_prologue是GC前调用的执行GC的准备工作，gc_epilogue是GC结束后调用的执行GC的扫尾工作，恢复部分标识到初始状态，其实现如下：
void ConcurrentMarkSweepGeneration::gc_prologue(bool full) {
//记录GC开始前的容量和使用量
_capacity_at_prologue = capacity();
_used_at_prologue = used();
collector()->gc_prologue(full);
}
inline size_t ConcurrentMarkSweepGeneration::capacity() const {
return _cmsSpace->capacity();
}
inline size_t ConcurrentMarkSweepGeneration::used() const {
return _cmsSpace->used();
}
void CMSCollector::gc_prologue(bool full) {
//校验当前在安全点上
assert(SafepointSynchronize::is_at_safepoint(), "world is stopped assumption");
//CMSScavengeBeforeRemark表示在CMS remark前是否尝试扫描，默认为false
//校验当前线程是VM Thread或者CMS Thread
assert( Thread::current()->is_VM_thread()
|| ( CMSScavengeBeforeRemark
&& Thread::current()->is_ConcurrentGC_thread()),
"Incorrect thread type for prologue execution");
if (_between_prologue_and_epilogue) {
//已经调用过一次了
return;
}
//将_between_prologue_and_epilogue由false改成true
_between_prologue_and_epilogue = true;
//获取锁freelistLock
getFreelistLocks();
//获取bitMapLock
bitMapLock()->lock_without_safepoint_check();
//是否处在标记阶段
bool duringMarking = _collectorState >= Marking
&& _collectorState < Sweeping;
//告诉年轻代记录发生修改的Klass
if (duringMarking) {
_ct->klass_rem_set()->set_accumulate_modified_oops(true);
}
bool registerClosure = duringMarking;
ModUnionClosure* muc = CollectedHeap::use_parallel_gc_threads() ?
&_modUnionClosurePar
: &_modUnionClosure;
_cmsGen->gc_prologue_work(full, registerClosure, muc);
if (!full) {
//如果不是Full GC
stats().record_gc0_begin();
}
}
void CMSCollector::getFreelistLocks() const {
_cmsGen->freelistLock()->lock_without_safepoint_check();
}
Mutex* bitMapLock() const { return _markBitMap.lock(); }
void ConcurrentMarkSweepGeneration::gc_prologue_work(bool full,
bool registerClosure, ModUnionClosure* modUnionClosure) {
//校验_incremental_collection_failed属性未设置
assert(!incremental_collection_failed(), "Shouldn't be set yet");
assert(cmsSpace()->preconsumptionDirtyCardClosure() == NULL,
"Should be NULL");
if (registerClosure) {
//这个是父类Space的属性
cmsSpace()->setPreconsumptionDirtyCardClosure(modUnionClosure);
}
cmsSpace()->gc_prologue();
}
void ConcurrentMarkSweepGeneration::gc_epilogue(bool full) {
collector()->gc_epilogue(full);
// Also reset promotion tracking in par gc thread states.
if (CollectedHeap::use_parallel_gc_threads()) {
for (uint i = 0; i < ParallelGCThreads; i++) {
_par_gc_thread_states[i]->promo.stopTrackingPromotions(i);
}
}
}
void CMSCollector::gc_epilogue(bool full) {
//校验当前在安全点上
assert(SafepointSynchronize::is_at_safepoint(),
"world is stopped assumption");
//校验当前线程是VM Thread或者CMS Thread
assert( Thread::current()->is_VM_thread()
|| ( CMSScavengeBeforeRemark
&& Thread::current()->is_ConcurrentGC_thread()),
"Incorrect thread type for epilogue execution");
if (!_between_prologue_and_epilogue) {
//_between_prologue_and_epilogue为false说明未调用prologue方法
return;
}
//校验获取了锁
assert(haveFreelistLocks(), "must have freelist locks");
assert_lock_strong(bitMapLock());
//将标识重置为false
_ct->klass_rem_set()->set_accumulate_modified_oops(false);
_cmsGen->gc_epilogue_work(full);
if (_collectorState == AbortablePreclean || _collectorState == Precleaning) {
//如果是这两种状态，将_start_sampling置为true
_start_sampling = true;
}
//重置为0
_eden_chunk_index = 0;
//更新计数器
size_t cms_used = _cmsGen->cmsSpace()->used();
_cmsGen->update_counters(cms_used);
if (CMSIncrementalMode) {
//更新_icms_start_limit和_icms_stop_limit，并将soft_end重置为_icms_start_limit
icms_update_allocation_limits();
}
//释放锁
bitMapLock()->unlock();
releaseFreelistLocks();
if (!CleanChunkPoolAsync) {
//清理ChunkPool
Chunk::clean_chunk_pool();
}
//did_compact和_between_prologue_and_epilogue都置为false，恢复初始状态
set_did_compact(false);
_between_prologue_and_epilogue = false; // ready for next cycle
}
void ConcurrentMarkSweepGeneration::gc_epilogue_work(bool full) {
assert(!incremental_collection_failed(), "Should have been cleared");
cmsSpace()->setPreconsumptionDirtyCardClosure(NULL);
cmsSpace()->gc_epilogue();
if (PrintGC && Verbose) {
gclog_or_tty->print(" Contiguous available " SIZE_FORMAT " bytes ",
contiguous_available());
}
}8、should_collect / should_concurrent_collect / is_too_full / collect
should_collect用于判断是否执行垃圾回收，should_concurrent_collect用于判断当前是否应该垃圾回收，is_too_full用于判断当前老年代空间是否太满了，collect用于执行垃圾回收。其实现如下：
bool ConcurrentMarkSweepGeneration::should_collect(bool full,
size_t size,
bool tlab)
{
return full || should_allocate(size, tlab); // FIX ME !!!
}
virtual bool should_allocate(size_t word_size, bool is_tlab) {
bool result = false;
size_t overflow_limit = (size_t)1 << (BitsPerSize_t - LogHeapWordSize);
if (!is_tlab || supports_tlab_allocation()) {
result = (word_size > 0) && (word_size < overflow_limit);
}
return result;
}
virtual bool supports_tlab_allocation() const { return false; }
bool ConcurrentMarkSweepGeneration::should_concurrent_collect() const {
assert_lock_strong(freelistLock());
//如果已使用率大于初始使用率
if (occupancy() > initiating_occupancy()) {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print(" %s: collect because of occupancy %f / %f ",
short_name(), occupancy(), initiating_occupancy());
}
return true;
}
//UseCMSInitiatingOccupancyOnly表示是否将initiating_occupancy作为唯一指标，默认为false
if (UseCMSInitiatingOccupancyOnly) {
return false;
}
//如果扩展的原因是因为满足内存分配的需求，则返回true
if (expansion_cause() == CMSExpansionCause::_satisfy_allocation) {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print(" %s: collect because expanded for allocation ",
short_name());
}
return true;
}
//如果cmsSpace应该进行垃圾收集
if (_cmsSpace->should_concurrent_collect()) {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print(" %s: collect because cmsSpace says so ",
short_name());
}
return true;
}
return false;
}
double occupancy() const { return ((double)used())/((double)capacity()); }
double initiating_occupancy() const { return _initiating_occupancy; }
CMSExpansionCause::Cause expansion_cause() const { return _expansion_cause; }
bool CompactibleFreeListSpace::should_concurrent_collect() const {
return !adaptive_freelists() && linearAllocationWouldFail();
}
bool CompactibleFreeListSpace::linearAllocationWouldFail() const {
return _smallLinearAllocBlock._word_size == 0;
}
bool ConcurrentMarkSweepGeneration::is_too_full() const {
bool res = should_concurrent_collect();
//CMSIsTooFullPercentage的默认值是98，是一个阈值，超过该值认为空间太满了
res = res && (occupancy() > (double)CMSIsTooFullPercentage/100.0);
return res;
}
void ConcurrentMarkSweepGeneration::collect(bool full,
bool clear_all_soft_refs,
size_t size,
bool tlab)
{
collector()->collect(full, clear_all_soft_refs, size, tlab);
}
void CMSCollector::collect(bool full,
bool clear_all_soft_refs,
size_t size,
bool tlab)
{
//UseCMSCollectionPassing默认为true，表示是否将GC从后台调整到前台
if (!UseCMSCollectionPassing && _collectorState > Idling) {
if (TraceCMSState) {
gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " skipped full:%d CMS state %d",
Thread::current(), full, _collectorState);
}
return;
}
if (GC_locker::is_active()) {
//如果正在执行GC
assert(GC_locker::needs_gc(), "Should have been set already");
//等待GC完成后，重新计算老年代容量
compute_new_size();
return;
}
//执行GC
acquire_control_and_collect(full, clear_all_soft_refs);
//计数增加
_full_gcs_since_conc_gc++;
}其调用链如下：
9、compute_new_size / compute_new_size_free_list
compute_new_size和compute_new_size_free_list都是GC结束后根据当前内存使用情况重新计算期望的内存容量，并做适当的扩容或者缩容处理，最大的不同是调用方不一样，其实现如下：
void ConcurrentMarkSweepGeneration::compute_new_size() {
assert_locked_or_safepoint(Heap_lock);
//如果增量收集失败了，扩容到最大容量
if (incremental_collection_failed()) {
clear_incremental_collection_failed();
grow_to_reserved();
return;
}
//根据GC后的内存使用情况计算新的内存容量，并做扩容或者缩容处理
CardGeneration::compute_new_size();
if (did_compact()) {
//如果执行压缩了，则执行压缩后的重置
cmsSpace()->reset_after_compaction();
}
}
void ConcurrentMarkSweepGeneration::compute_new_size_free_list() {
assert_locked_or_safepoint(Heap_lock);
//如果增量收集失败了，扩容到最大容量
if (incremental_collection_failed()) {
clear_incremental_collection_failed();
grow_to_reserved();
return;
}
//当前空闲空间的百分比
double free_percentage = ((double) free()) / capacity();
double desired_free_percentage = (double) MinHeapFreeRatio / 100;
double maximum_free_percentage = (double) MaxHeapFreeRatio / 100;
// compute expansion delta needed for reaching desired free percentage
if (free_percentage < desired_free_percentage) {
//当前空闲占比小于期望的最小空闲占比，需要扩容
size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage));
assert(desired_capacity >= capacity(), "invalid expansion size");
//计算扩容的内存空间
size_t expand_bytes = MAX2(desired_capacity - capacity(), MinHeapDeltaBytes);
if (PrintGCDetails && Verbose) {
size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage));
gclog_or_tty->print_cr("\nFrom compute_new_size: ");
gclog_or_tty->print_cr(" Free fraction %f", free_percentage);
gclog_or_tty->print_cr(" Desired free fraction %f",
desired_free_percentage);
gclog_or_tty->print_cr(" Maximum free fraction %f",
maximum_free_percentage);
gclog_or_tty->print_cr(" Capactiy " SIZE_FORMAT, capacity()/1000);
gclog_or_tty->print_cr(" Desired capacity " SIZE_FORMAT,
desired_capacity/1000);
int prev_level = level() - 1;
if (prev_level >= 0) {
size_t prev_size = 0;
GenCollectedHeap* gch = GenCollectedHeap::heap();
Generation* prev_gen = gch->_gens[prev_level];
prev_size = prev_gen->capacity();
gclog_or_tty->print_cr(" Younger gen size " SIZE_FORMAT,
prev_size/1000);
}
gclog_or_tty->print_cr(" unsafe_max_alloc_nogc " SIZE_FORMAT,
unsafe_max_alloc_nogc()/1000);
gclog_or_tty->print_cr(" contiguous available " SIZE_FORMAT,
contiguous_available()/1000);
gclog_or_tty->print_cr(" Expand by " SIZE_FORMAT " (bytes)",
expand_bytes);
}
//执行扩容
expand(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio);
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr(" Expanded free fraction %f",
((double) free()) / capacity());
}
} else {
//空闲占比大于最小空闲占比，需要适当缩容
size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage));
assert(desired_capacity <= capacity(), "invalid expansion size");
//计算缩容的空间
size_t shrink_bytes = capacity() - desired_capacity;
if (shrink_bytes >= MinHeapDeltaBytes) {
//执行缩容
shrink_free_list_by(shrink_bytes);
}
}
}
其调用链如下：
3968
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
