void oop_field_store(oop* field, oop value) {
pre_write_barrier(field);
*field = value; // the actual store
post_write_barrier(field, value);
}void oop_field_store(oop* field, oop new_value) {
pre_write_barrier(field); // pre-write barrier: for maintaining SATB invariant
*field = new_value; // the actual store
post_write_barrier(field, new_value); // post-write barrier: for tracking cross-region reference
}void pre_write_barrier(oop* field) {
if ($gc_phase == GC_CONCURRENT_MARK) { // SATB invariant only maintained during concurrent marking
oop old_value = *field;
if (old_value != null && !is_marked(old_value)) {
mark_object(old_value);
$mark_stack->push(old_value); // scan all of old_value's fields later
}
}
}void pre_write_barrier(oop* field) {
oop old_value = *field;
if (old_value != null) {
if ($gc_phase == GC_CONCURRENT_MARK) { // SATB invariant only maintained during concurrent marking
$current_thread->satb_mark_queue->enqueue(old_value);
}
}
} // This notes that we don't need to access any BarrierSet data
// structures, so this can be called from a static context.
template <class T> static void write_ref_field_pre_static(T* field, oop newVal) {
T heap_oop = oopDesc::load_heap_oop(field);
if (!oopDesc::is_null(heap_oop)) {
enqueue(oopDesc::decode_heap_oop(heap_oop));
}
}JavaThread::satb_mark_queue_set().is_active()
void post_write_barrier(oop* field, oop new_value) {
uintptr_t field_uint = (uintptr_t) field;
uintptr_t new_value_uint = (uintptr_t) new_value;
uintptr_t comb = (field_uint ^ new_value_uint) >> HeapRegion::LogOfHRGrainBytes;
if (comb == 0) return; // field and new_value are in the same region
if (new_value == null) return; // filter out null stores
// Otherwise, add to remembered set
// first, add to card table
volatile jbyte* card_ptr = card_for(field); // get pointer to the card for this field
// in generational G1 mode, skip dirtying cards for young gen regions,
// -- young gen regions are always collected
// if (*card_ptr == g1_young_gen) return;
if (*card_ptr != dirty_card) {
// dirty the card to reduce the work for multiple stores to the same card
*card_ptr = dirty_card;
// clean the card the get ready to do the real work
*card_ptr = clean_card;
// find the memory region representing the card
HeapWord* start = $card_table->addr_for(card_ptr);
HeapWord* end = start + CARD_SIZE_IN_WORDS;
MemRegion* dirty_mem_region(start, end);
// and find the G1 heap region containing the card
HeapRegion* from_region = $g1_heap->heap_region_containing(start);
// scan all reference fields in dirtied region
foreach (oop from_obj in dirty_mem_region) {
foreach (oop* f in from_obj->oop_fields()) {
oop to_obj = *f;
HeapRegion* to_region = $g1_heap->heap_region_containing(to_obj);
if (from_region != to_region) {
CardIdx_t from_card = from_region->card_index_for(card_ptr);
to_region->remembered_set->add_reference(from_region, from_card);
}
}
}
}
}void post_write_barrier(oop* field, oop new_value) {
uintptr_t field_uint = (uintptr_t) field;
uintptr_t new_value_uint = (uintptr_t) new_value;
uintptr_t comb = (field_uint ^ new_value_uint) >> HeapRegion::LogOfHRGrainBytes;
if (comb == 0) return; // field and new_value are in the same region
if (new_value == null) return; // filter out null stores
// Otherwise, log it
volatile jbyte* card_ptr = card_for(field); // get address of the card for this field
// in generational G1 mode, skip dirtying cards for young gen regions,
// -- young gen regions are always collected
// if (*card_ptr == g1_young_gen) return;
if (*card_ptr != dirty_card) {
// dirty the card to reduce the work for multiple stores to the same card
*card_ptr = dirty_card;
// log the card for concurrent remembered set refinement
JavaThread::current()->dirty_card_queue->enqueue(card_ptr);
}
}感谢R大的回复，不过关于收集模式这块我越来越糊涂了，之前看到的资料说G1采取了CMS的优点，可以并发收集，过程如下：
| 初始标记（initial mark，STW） | 它标记了从GC Root开始直接可达的对象。 |
| 并发标记（Concurrent Marking） |
这个阶段从GC Root开始对heap中的对象标记，标记线程与应用程序线程并行执行， 并且收集各个Region的存活对象信息。 |
| 最终标记（Remark，STW） | 标记那些在并发标记阶段发生变化的对象，空Region（没有存活对象的）将被回收 |
| 清除垃圾/拷贝（Cleanup/ Copy） |
根据并发标记阶段收集的信息，排序待收集的Region，存活对象少的优先收集， 再根据目标停止时间，动态计算出收集队列长度，将符合条件的Region中的存活 对象拷贝到空Region中。 |
代码在
// concurrentMarkThread.cpp
void ConcurrentMarkThread::run() {
// initial mark
_cm->scanRootRegions();
do {
if (!cm()->has_aborted()) {
// concurrent mark
_cm->markFromRoots();
}
// remark
CMCheckpointRootsFinalClosure final_cl(_cm);
VM_CGC_Operation op(&final_cl, "GC remark", true /* needs_pll */);
VMThread::execute(&op);
} while (cm()->restart_for_overflow());
// cleanup
CMCleanUp cl_cl(_cm);
VM_CGC_Operation op(&cl_cl, "GC cleanup", false /* needs_pll */);
VMThread::execute(&op);
......
}
而又有一些说法是minor gc是 STW的，显然并发收集不能适用于YGC，代码如下（请R大帮忙确认下是否正确）
void G1MarkSweep::invoke_at_safepoint(ReferenceProcessor* rp,
bool clear_all_softrefs) {
......
// Mark live objects
mark_sweep_phase1(marked_for_unloading, clear_all_softrefs);
// Calculate new addresses
static void mark_sweep_phase2();
// Update pointers
static void mark_sweep_phase3();
// Move objects to new positions
static void mark_sweep_phase4();
......
}
而根据你的回答
[quote="RednaxelaFX"]
首先要先认识清楚G1的几种收集模式：
1、young GC（或者叫minor GC）：只收集young gen里的所有region，也就是eden和survivor。控制young GC开销的手段是动态改变young region的个数；
2、mixed GC：收集young gen里的所有region，外加若干选定的old gen region。控制mixed GC开销的手段是选多少个、哪几个old gen region。
3、其实没有3了。G1 GC的控制范围内没有full GC。如果mixed GC无法跟上mutator分配的速度，导致没有足够的空region来完成mixed GC，那么就会使用serial old GC（ mark-compact）来对整堆收集一次。
[/quote]
我只能推测concurrent gc适用于mixed GC中的old gen 收集，不知道是不是这样？关于你说的第三点，full gc是退化为serial old GC，能指出相关的代码吗？
| mutator | collector | remembered set thread | |
| 初始标记 | cell11：NA | 标记所有root直接引用的对象，同时将这些对象中的引用字段入栈 | cell13：NA |
| 并发标记 |
开启write barrier，使每个写操作包括如下步骤 write(field, val): 1。old = *field 2。old如果为null则结束 3。将old加入当前线程的satb_mark_queue 4。*field=value 5。检查field与val是否处于同一个region，是则结束 6。检查field指向的位置所处的card是否为dirty，是则结束 7。将field指向的位置所处的card置dirty，同时将该card加入当前线程的dirty_card_queue 8。write结束 |
1。从栈中弹出一个ref，设其引用的对象为obj 2。检查obj是否已经marked，是则返回第1步 3。mark obj，遍历其所有引用，设为r： 3.1。将r压入当前线程的mark_stack 3.2。检查r，看其指向对象与obj是否在同一个region中，是则continue 3.3。设r指向的对象所在的region为R，为R的remembered set（简称rs）添加一笔表示obj所在region及card的记录 4。重复上述过程直到栈为空 |
1。从各线程的dirty_card_queue中以某种方式取出一个card 2。遍历该card中所有obj的所有ref： 2.1。如果ref指向对象与obj在同一个region，则continue 2.2。设ref指向的对象所处region为R，则为R的rs添加一笔表示obj所在region及card的记录 |
| 最终标记 | NA | ？ | NA |
| 清理 | ？ | ？ | ？ |
上面是我基于对R大之前回复的理解做的一张表，请R大看看我目前的理解是否有偏差。
另外有如下问题：
1.cell22中对mark stack的使用不知是否有问题？
2.cell22未涉及对SATB queue的处理，应该何时处理以及如何处理？
3.能否请R大指教，帮我完成这个表的剩余部分，这两天也仔细看了论文，但感觉还是无法完整的填写好这张表
size_t marking_initiating_used_threshold = (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent;
size_t cur_used_bytes = _g1->non_young_capacity_bytes();
size_t alloc_byte_size = alloc_word_size * HeapWordSize;
if ((cur_used_bytes + alloc_byte_size) > marking_initiating_used_threshold) {
.......
}
double get_new_prediction(TruncatedSeq* seq) {
return MAX2(seq->davg() + sigma() * seq->dsd(),
seq->davg() * confidence_factor(seq->num()));
}