图解分析:https://cloud.tencent.com/developer/article/1739895
Hotspot为每一个代 都设置了 各自的 level,也就是等级,年轻代 level 一般为 0, 老年代 level 一般为 1。
在默认的年轻代(/vm/memory/defNewGeneration.cpp)下的实现:
defNewGeneration::collect 有如下重要调用点:
1. gch->gen_process_strong_roots(_level,
true, // Process younger gens, if any,
// as strong roots.
true, // activate StrongRootsScope
false, // not collecting perm generation.
SharedHeap::SO_AllClasses,
&fsc_with_no_gc_barrier,
true, // walk *all* scavengable nmethods
&fsc_with_gc_barrier);
// "evacuate followers".
2. evacuate_followers.do_void();
3. rp->process_discovered_references(&is_alive, &keep_alive, &evacuate_followers,
NULL);
重要的闭包:FastScanClosure :: do_oop_work :将 接收的参数是 T * (其实也就是 oop *) , 是指向 oop 的指针
oop 本身就是 oopDesc * 的缩写,也就是 java 在 C++ 层面的对象的指针,所以修改 T* 指向的内存单元,就可以修改这个内存单元指向的oop,相当于修改对象的引用类型变量
入参的 do_barriar 如果为 true,则在处理 T* 时,需要将该引用指向的地址的卡表,设置为 younggen_card (未知作用)
概述:
1.gen_process_strong_roots
处理根节点引用的oop,包括Java方法堆栈,JNI方法堆栈,符号表等引用的对象
2.evacuate_followers
负责将 从年轻代promote到老年代的对象,使用 入参为 true 的 FastScanClosure 作为参数,调用这些对象的 oop_iterate, 也就是遍历这些对象的引用类型
也就是遍历这些对象的引用类型变量,如果年龄到阈值,则promote到老年代,否则复制到 to 区
3.处理Java提供的各种非强引用
1.gen_process_strong_roots
该方法的实现在 GenCollectedHeap 中
// General strong roots.
if (!do_code_roots) {
SharedHeap::process_strong_roots(activate_scope, collecting_perm_gen, so,
not_older_gens, NULL, older_gens);
} else {
bool do_code_marking = (activate_scope || nmethod::oops_do_marking_is_active());
CodeBlobToOopClosure code_roots(not_older_gens, /*do_marking=*/ do_code_marking);
SharedHeap::process_strong_roots(activate_scope, collecting_perm_gen, so,
not_older_gens, &code_roots, older_gens);
}
if (younger_gens_as_roots) {
if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
for (int i = 0; i < level; i++) {
not_older_gens->set_generation(_gens[i]);
_gens[i]->oop_iterate(not_older_gens);
}
not_older_gens->reset_generation();
}
}
// When collection is parallel, all threads get to cooperate to do
// older-gen scanning.
for (int i = level+1; i < _n_gens; i++) {
older_gens->set_generation(_gens[i]);
rem_set()->younger_refs_iterate(_gens[i], older_gens);
older_gens->reset_generation();
}
younger_refs_in_space_iterate
_gen_process_strong_tasks->all_tasks_completed();
最重要的三个点是
1.process_strong_roots 对根节点使用某个特定的 closure,上文中是 not_older_gens,即不是针对老年代的 Clsoure
2.第一个循环的 oop_iterate 倘若是老年代调用 gen_process_strong_roots ,则level是1,也就是会调用循环中的本 oop_iterate , 年轻代的level 是 0,所以不会调用。本oop_iterate是使用 not_older_gens 的 closure 去处理oop的引用类型
3.第二个循环的 younger_refs_iterate 是用来遍历脏卡表的,上面用的是 older_gens 去遍历脏卡表对应区域引用的对象
1.process_strong_roots
void SharedHeap::process_strong_roots(bool activate_scope,
bool collecting_perm_gen,
ScanningOption so,
OopClosure* roots,
CodeBlobClosure* code_roots,
OopsInGenClosure* perm_blk) {
StrongRootsScope srs(this, activate_scope);
// General strong roots.
assert(_strong_roots_parity != 0, "must have called prologue code");
if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
Universe::oops_do(roots); //1
ReferenceProcessor::oops_do(roots);
// Consider perm-gen discovered lists to be strong.
perm_gen()->ref_processor()->weak_oops_do(roots);
}
// Global (strong) JNI handles
if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
JNIHandles::oops_do(roots); //2
// All threads execute this; the individual threads are task groups.
if (ParallelGCThreads > 0) {
Threads::possibly_parallel_oops_do(roots, code_roots);
} else {
Threads::oops_do(roots, code_roots); //3
}
if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
ObjectSynchronizer::oops_do(roots); //4
if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
FlatProfiler::oops_do(roots); //5
if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
Management::oops_do(roots); //6
if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
JvmtiExport::oops_do(roots); //7
if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
if (so & SO_AllClasses) {
SystemDictionary::oops_do(roots); //8
} else if (so & SO_SystemClasses) {
SystemDictionary::always_strong_oops_do(roots);
}
}
if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
if (so & SO_Strings || (!collecting_perm_gen && !JavaObjectsInPerm)) {
StringTable::oops_do(roots); //9
}
if (JavaObjectsInPerm) {
// Verify the string table contents are in the perm gen
NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure));
}
}
if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
if (so & SO_CodeCache) {
// (Currently, CMSCollector uses this to do intermediate-strength collections.)
assert(collecting_perm_gen, "scanning all of code cache");
assert(code_roots != NULL, "must supply closure for code cache");
if (code_roots != NULL) {
CodeCache::blobs_do(code_roots);
}
} else if (so & (SO_SystemClasses|SO_AllClasses)) {
if (!collecting_perm_gen) {
// If we are collecting from class statics, but we are not going to
// visit all of the CodeCache, collect from the non-perm roots if any.
// This makes the code cache function temporarily as a source of strong
// roots for oops, until the next major collection.
//
// If collecting_perm_gen is true, we require that this phase will call
// CodeCache::do_unloading. This will kill off nmethods with expired
// weak references, such as stale invokedynamic targets.
CodeCache::scavenge_root_nmethods_do(code_roots);
}
}
// Verify that the code cache contents are not subject to
// movement by a scavenging collection.
DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, /*do_marking=*/ false));
DEBUG_ONLY(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_non_scavengable));
}
if (!collecting_perm_gen) {
// All threads perform this; coordination is handled internally.
rem_set()->younger_refs_iterate(perm_gen(), perm_blk);
}
_process_strong_tasks->all_tasks_completed();
}
1.Universe : 某些全局量持有的对象引用,比如:
mirror 是某个类静态遍历的集合,比如说有 Class A { static int a ; int b; static A c;}
那么这个类的 mirror 就是 一个 12 字节的 oop,其实只是 12 字节的连续内存 区块。其中存放了 4 字节的 int 类型变量,8字节的指针类型变量
上面这些 mirror 都是 java 提供的基础类型 的类 的 静态变量集合。每个集合 在 jvm 的 C++ 层面称为 oopDesc 。 oop 是 oopDesc * , 即oopDesc 的指针
f 在当前语境下是 FastScanClosure,并且 处理 oop * 后不会把这个 oop * 的卡置为 youngercard,FastScanClosure的处理逻辑如下:把 oop * 的值引用的 oopDesc 复制到 to 或 老年代(年龄够了的情况下)
注意 oop * 是 oopDesc 的指针的指针,也就是 oop * 是一个8字节的内存地址,指向的地方的8字节处是 oop,也是 一个 8 字节的内存地址,指向的地方是一个 oopDesc
所以通过 f 修改 oop * 指向的内存区域,就是在修改某个 C++ 层面的类或结构(此处是 Universe)的指针域
关于 f :do_oop 会调用 do_oop_work
下面的逻辑是,如果对象没有被复制到别的地方,也就是 forwardee 指针是空,就尝试把对象复制到 to 区,或 promote 到 老年代
针对年轻代的 _gc_barrier 是 false
do_barrier 会把 oop * 在卡表中对应字节(一个字节代表一张卡)的值设置为youngercard
每种 generation 都有自己 copy_to_survivor_space 的实现,以下是默认年轻代的实现
oop DefNewGeneration::copy_to_survivor_space(oop old) {
assert(is_in_reserved(old) && !old->is_forwarded(),
"shouldn't be scavenging this oop");
size_t s = old->size();
oop obj = NULL;
// Try allocating obj in to-space (unless too old)
if (old->age() < tenuring_threshold()) {
obj = (oop) to()->allocate(s);
}
// Otherwise try allocating obj tenured
if (obj == NULL) {
obj = _next_gen->promote(old, s);
if (obj == NULL) {
handle_promotion_failure(old);
return old;
}
} else {
// Prefetch beyond obj
const intx interval = PrefetchCopyIntervalInBytes;
Prefetch::write(obj, interval);
// Copy obj
Copy::aligned_disjoint_words((HeapWord*)old, (HeapWord*)obj, s);
// Increment age if obj still in new generation
obj->incr_age();
age_table()->add(obj, s);
}
// Done, insert forward pointer to obj in this header
old->forward_to(obj);
return obj;
}
上面的1~9就是所谓的根节点,其中比较重要的几个是 Universe,java线程栈中的oop ,jni持有的 oop
3.younger_refs_iterate
这个方法会遍历脏卡表项对应内存区的对象的引用,而且是针对老年代的。
比如老年代有个对象 A 持有一个引用 b 指向 对象 B,实际上, A 和 B 都是 oopDesc, b 在 c ++ 层面就是一个 oop,也就是 oopDesc *
当 A 的 b 引用 指向了其他对象,也就是 A.b = xxx , 那么 A 的 b 此时会指向 xxx 这个 oopDesc,此时 A 对应内存区的卡 就是一片脏卡,对应的卡表项就是脏的。
所以要用 f 处理 A, 在处理之前会把 A 的内存对应卡表项置位干净卡。f 的入参是 A 的各个 oop 的地址
比如 A 在 C ++ 层面的内存表示是: