< prev index next >
src/share/vm/gc/g1/heapRegion.cpp
Print this page
rev 13047 : imported patch 8071280-specialize-heapregion-oops-on-card-seq-iterate
*** 347,462 ****
"marked: " SIZE_FORMAT " used: " SIZE_FORMAT, marked_bytes, used());
_prev_top_at_mark_start = top();
_prev_marked_bytes = marked_bytes;
}
- // Humongous objects are allocated directly in the old-gen. Need
- // special handling for concurrent processing encountering an
- // in-progress allocation.
- static bool do_oops_on_card_in_humongous(MemRegion mr,
- G1UpdateRSOrPushRefOopClosure* cl,
- HeapRegion* hr,
- G1CollectedHeap* g1h) {
- assert(hr->is_humongous(), "precondition");
- HeapRegion* sr = hr->humongous_start_region();
- oop obj = oop(sr->bottom());
-
- // If concurrent and klass_or_null is NULL, then space has been
- // allocated but the object has not yet been published by setting
- // the klass. That can only happen if the card is stale. However,
- // we've already set the card clean, so we must return failure,
- // since the allocating thread could have performed a write to the
- // card that might be missed otherwise.
- if (!g1h->is_gc_active() && (obj->klass_or_null_acquire() == NULL)) {
- return false;
- }
-
- // We have a well-formed humongous object at the start of sr.
- // Only filler objects follow a humongous object in the containing
- // regions, and we can ignore those. So only process the one
- // humongous object.
- if (!g1h->is_obj_dead(obj, sr)) {
- if (obj->is_objArray() || (sr->bottom() < mr.start())) {
- // objArrays are always marked precisely, so limit processing
- // with mr. Non-objArrays might be precisely marked, and since
- // it's humongous it's worthwhile avoiding full processing.
- // However, the card could be stale and only cover filler
- // objects. That should be rare, so not worth checking for;
- // instead let it fall out from the bounded iteration.
- obj->oop_iterate(cl, mr);
- } else {
- // If obj is not an objArray and mr contains the start of the
- // obj, then this could be an imprecise mark, and we need to
- // process the entire object.
- obj->oop_iterate(cl);
- }
- }
- return true;
- }
-
- bool HeapRegion::oops_on_card_seq_iterate_careful(MemRegion mr,
- G1UpdateRSOrPushRefOopClosure* cl) {
- assert(MemRegion(bottom(), end()).contains(mr), "Card region not in heap region");
- G1CollectedHeap* g1h = G1CollectedHeap::heap();
-
- // Special handling for humongous regions.
- if (is_humongous()) {
- return do_oops_on_card_in_humongous(mr, cl, this, g1h);
- }
- assert(is_old(), "precondition");
-
- // Because mr has been trimmed to what's been allocated in this
- // region, the parts of the heap that are examined here are always
- // parsable; there's no need to use klass_or_null to detect
- // in-progress allocation.
-
- // Cache the boundaries of the memory region in some const locals
- HeapWord* const start = mr.start();
- HeapWord* const end = mr.end();
-
- // Find the obj that extends onto mr.start().
- // Update BOT as needed while finding start of (possibly dead)
- // object containing the start of the region.
- HeapWord* cur = block_start(start);
-
- #ifdef ASSERT
- {
- assert(cur <= start,
- "cur: " PTR_FORMAT ", start: " PTR_FORMAT, p2i(cur), p2i(start));
- HeapWord* next = cur + block_size(cur);
- assert(start < next,
- "start: " PTR_FORMAT ", next: " PTR_FORMAT, p2i(start), p2i(next));
- }
- #endif
-
- do {
- oop obj = oop(cur);
- assert(obj->is_oop(true), "Not an oop at " PTR_FORMAT, p2i(cur));
- assert(obj->klass_or_null() != NULL,
- "Unparsable heap at " PTR_FORMAT, p2i(cur));
-
- if (g1h->is_obj_dead(obj, this)) {
- // Carefully step over dead object.
- cur += block_size(cur);
- } else {
- // Step over live object, and process its references.
- cur += obj->size();
- // Non-objArrays are usually marked imprecise at the object
- // start, in which case we need to iterate over them in full.
- // objArrays are precisely marked, but can still be iterated
- // over in full if completely covered.
- if (!obj->is_objArray() || (((HeapWord*)obj) >= start && cur <= end)) {
- obj->oop_iterate(cl);
- } else {
- obj->oop_iterate(cl, mr);
- }
- }
- } while (cur < end);
-
- return true;
- }
-
// Code roots support
void HeapRegion::add_strong_code_root(nmethod* nm) {
HeapRegionRemSet* hrrs = rem_set();
hrrs->add_strong_code_root(nm);
--- 347,356 ----
< prev index next >