< prev index next >
src/share/vm/gc/shenandoah/shenandoahHeap.inline.hpp
Print this page
rev 14451 : imported patch bitmap_uncommit.patch
rev 14452 : [mq]: onebitmap.patch
*** 61,71 ****
/*
* Marks the object. Returns true if the object has not been marked before and has
* been marked by this thread. Returns false if the object has already been marked,
* or if a competing thread succeeded in marking this object.
*/
! inline bool ShenandoahHeap::mark_next(oop obj) const {
#ifdef ASSERT
if (! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))) {
tty->print_cr("heap region containing obj:");
ShenandoahHeapRegion* obj_region = heap_region_containing(obj);
obj_region->print();
--- 61,71 ----
/*
* Marks the object. Returns true if the object has not been marked before and has
* been marked by this thread. Returns false if the object has already been marked,
* or if a competing thread succeeded in marking this object.
*/
! inline bool ShenandoahHeap::mark(oop obj) {
#ifdef ASSERT
if (! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))) {
tty->print_cr("heap region containing obj:");
ShenandoahHeapRegion* obj_region = heap_region_containing(obj);
obj_region->print();
*** 74,99 ****
forward_region->print();
}
#endif
assert(oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj)), "only mark forwarded copy of objects");
! return mark_next_no_checks(obj);
}
! inline bool ShenandoahHeap::mark_next_no_checks(oop obj) const {
HeapWord* addr = (HeapWord*) obj;
! return (! allocated_after_next_mark_start(addr)) && _next_mark_bit_map->parMark(addr);
}
! inline bool ShenandoahHeap::is_marked_next(oop obj) const {
HeapWord* addr = (HeapWord*) obj;
! return allocated_after_next_mark_start(addr) || _next_mark_bit_map->isMarked(addr);
! }
!
! inline bool ShenandoahHeap::is_marked_complete(oop obj) const {
! HeapWord* addr = (HeapWord*) obj;
! return allocated_after_complete_mark_start(addr) || _complete_mark_bit_map->isMarked(addr);
}
inline bool ShenandoahHeap::need_update_refs() const {
return _need_update_refs;
}
--- 74,94 ----
forward_region->print();
}
#endif
assert(oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj)), "only mark forwarded copy of objects");
! return mark_no_checks(obj);
}
! inline bool ShenandoahHeap::mark_no_checks(oop obj) {
HeapWord* addr = (HeapWord*) obj;
! return !allocated_after_mark_start(addr) && _mark_bit_map.parMark(addr);
}
! inline bool ShenandoahHeap::is_marked(oop obj) const {
HeapWord* addr = (HeapWord*) obj;
! return allocated_after_mark_start(addr) || _mark_bit_map.isMarked(addr);
}
inline bool ShenandoahHeap::need_update_refs() const {
return _need_update_refs;
}
*** 395,405 ****
return result;
}
}
inline bool ShenandoahHeap::requires_marking(const void* entry) const {
! return ! is_marked_next(oop(entry));
}
bool ShenandoahHeap::region_in_collection_set(size_t region_index) const {
assert(collection_set() != NULL, "Sanity");
return collection_set()->is_in(region_index);
--- 390,400 ----
return result;
}
}
inline bool ShenandoahHeap::requires_marking(const void* entry) const {
! return ! is_marked(oop(entry));
}
bool ShenandoahHeap::region_in_collection_set(size_t region_index) const {
assert(collection_set() != NULL, "Sanity");
return collection_set()->is_in(region_index);
*** 436,455 ****
inline address ShenandoahHeap::evacuation_in_progress_addr() {
return (address) &(ShenandoahHeap::heap()->_evacuation_in_progress);
}
! inline bool ShenandoahHeap::allocated_after_next_mark_start(HeapWord* addr) const {
! uintx index = ((uintx) addr) >> ShenandoahHeapRegion::region_size_bytes_shift();
! HeapWord* top_at_mark_start = _next_top_at_mark_starts[index];
! bool alloc_after_mark_start = addr >= top_at_mark_start;
! return alloc_after_mark_start;
! }
!
! inline bool ShenandoahHeap::allocated_after_complete_mark_start(HeapWord* addr) const {
uintx index = ((uintx) addr) >> ShenandoahHeapRegion::region_size_bytes_shift();
! HeapWord* top_at_mark_start = _complete_top_at_mark_starts[index];
bool alloc_after_mark_start = addr >= top_at_mark_start;
return alloc_after_mark_start;
}
template<class T>
--- 431,443 ----
inline address ShenandoahHeap::evacuation_in_progress_addr() {
return (address) &(ShenandoahHeap::heap()->_evacuation_in_progress);
}
! inline bool ShenandoahHeap::allocated_after_mark_start(HeapWord* addr) const {
uintx index = ((uintx) addr) >> ShenandoahHeapRegion::region_size_bytes_shift();
! HeapWord* top_at_mark_start = _top_at_mark_starts[index];
bool alloc_after_mark_start = addr >= top_at_mark_start;
return alloc_after_mark_start;
}
template<class T>
*** 465,484 ****
template<class T>
inline void ShenandoahHeap::marked_object_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit) {
assert(BrooksPointer::word_offset() < 0, "skip_delta calculation below assumes the forwarding ptr is before obj");
assert(! region->is_humongous_continuation(), "no humongous continuation regions here");
! MarkBitMap* mark_bit_map = _complete_mark_bit_map;
! HeapWord* top_at_mark_start = complete_top_at_mark_start(region->bottom());
size_t skip_bitmap_delta = BrooksPointer::word_size() + 1;
size_t skip_objsize_delta = BrooksPointer::word_size() /* + actual obj.size() below */;
HeapWord* start = region->bottom() + BrooksPointer::word_size();
! HeapWord* end = MIN2(top_at_mark_start + BrooksPointer::word_size(), region->end());
! HeapWord* addr = mark_bit_map->getNextMarkedWordAddress(start, end);
intx dist = ShenandoahMarkScanPrefetch;
if (dist > 0) {
// Batched scan that prefetches the oop data, anticipating the access to
// either header, oop field, or forwarding pointer. Not that we cannot
--- 453,473 ----
template<class T>
inline void ShenandoahHeap::marked_object_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit) {
assert(BrooksPointer::word_offset() < 0, "skip_delta calculation below assumes the forwarding ptr is before obj");
assert(! region->is_humongous_continuation(), "no humongous continuation regions here");
+ assert(is_bitmap_valid(), "only try this with complete marking bitmap");
! MarkBitMap mark_bit_map = _mark_bit_map;
! HeapWord* tams = top_at_mark_start(region->bottom());
size_t skip_bitmap_delta = BrooksPointer::word_size() + 1;
size_t skip_objsize_delta = BrooksPointer::word_size() /* + actual obj.size() below */;
HeapWord* start = region->bottom() + BrooksPointer::word_size();
! HeapWord* end = MIN2(tams + BrooksPointer::word_size(), region->end());
! HeapWord* addr = mark_bit_map.getNextMarkedWordAddress(start, end);
intx dist = ShenandoahMarkScanPrefetch;
if (dist > 0) {
// Batched scan that prefetches the oop data, anticipating the access to
// either header, oop field, or forwarding pointer. Not that we cannot
*** 501,553 ****
avail = 0;
for (int c = 0; (c < dist) && (addr < limit); c++) {
Prefetch::read(addr, BrooksPointer::byte_offset());
oop obj = oop(addr);
slots[avail++] = obj;
! if (addr < top_at_mark_start) {
addr += skip_bitmap_delta;
! addr = mark_bit_map->getNextMarkedWordAddress(addr, end);
} else {
// cannot trust mark bitmap anymore, finish the current stride,
// and switch to accurate traversal
addr += obj->size() + skip_objsize_delta;
aborting = true;
}
}
for (int c = 0; c < avail; c++) {
! do_marked_object(mark_bit_map, cl, slots[c]);
}
} while (avail > 0 && !aborting);
// accurate traversal
while (addr < limit) {
oop obj = oop(addr);
int size = obj->size();
! do_marked_object(mark_bit_map, cl, obj);
addr += size + skip_objsize_delta;
}
} else {
while (addr < limit) {
oop obj = oop(addr);
int size = obj->size();
! do_marked_object(mark_bit_map, cl, obj);
addr += size + skip_objsize_delta;
! if (addr < top_at_mark_start) {
! addr = mark_bit_map->getNextMarkedWordAddress(addr, end);
}
}
}
}
template<class T>
! inline void ShenandoahHeap::do_marked_object(MarkBitMap* bitmap, T* cl, oop obj) {
assert(!oopDesc::is_null(obj), "sanity");
assert(oopDesc::is_oop(obj), "sanity");
assert(is_in(obj), "sanity");
! assert(bitmap == _complete_mark_bit_map, "only iterate completed mark bitmap");
! assert(is_marked_complete(obj), "object expected to be marked");
cl->do_object(obj);
}
template <class T>
class ShenandoahObjectToOopClosure : public ObjectClosure {
--- 490,541 ----
avail = 0;
for (int c = 0; (c < dist) && (addr < limit); c++) {
Prefetch::read(addr, BrooksPointer::byte_offset());
oop obj = oop(addr);
slots[avail++] = obj;
! if (addr < tams) {
addr += skip_bitmap_delta;
! addr = mark_bit_map.getNextMarkedWordAddress(addr, end);
} else {
// cannot trust mark bitmap anymore, finish the current stride,
// and switch to accurate traversal
addr += obj->size() + skip_objsize_delta;
aborting = true;
}
}
for (int c = 0; c < avail; c++) {
! do_marked_object(cl, slots[c]);
}
} while (avail > 0 && !aborting);
// accurate traversal
while (addr < limit) {
oop obj = oop(addr);
int size = obj->size();
! do_marked_object(cl, obj);
addr += size + skip_objsize_delta;
}
} else {
while (addr < limit) {
oop obj = oop(addr);
int size = obj->size();
! do_marked_object(cl, obj);
addr += size + skip_objsize_delta;
! if (addr < tams) {
! addr = mark_bit_map.getNextMarkedWordAddress(addr, end);
}
}
}
}
template<class T>
! inline void ShenandoahHeap::do_marked_object(T* cl, oop obj) {
assert(!oopDesc::is_null(obj), "sanity");
assert(oopDesc::is_oop(obj), "sanity");
assert(is_in(obj), "sanity");
! assert(is_marked(obj), "object expected to be marked");
cl->do_object(obj);
}
template <class T>
class ShenandoahObjectToOopClosure : public ObjectClosure {
< prev index next >