truffle: src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 9337d0e7ea4f
children

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 CardTableModRefBS* ct_bs = g1h->g1_barrier_set();
 HeapWord* start = mr.start();
 HeapWord* end = mr.end();
 size_t region_size_bytes = mr.byte_size();
-uint index = hr->hrs_index();
+uint index = hr->hrm_index();
 assert(!hr->continuesHumongous(), "should not be HC region");
 assert(hr == g1h->heap_region_containing(start), "sanity");
 assert(hr == g1h->heap_region_containing(mr.last()), "sanity");
 assert(marked_bytes_array != NULL, "pre-condition");
 size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id);
 BitMap* task_card_bm = count_card_bitmap_for(worker_id);
 count_region(mr, hr, marked_bytes_array, task_card_bm);
 }
-// Counts the given memory region, which may be a single object, in the
-// task/worker counting data structures for the given worker id.
-inline void ConcurrentMark::count_region(MemRegion mr, uint worker_id) {
-HeapWord* addr = mr.start();
-HeapRegion* hr = _g1h->heap_region_containing_raw(addr);
-count_region(mr, hr, worker_id);
-}
 // Counts the given object in the given task/worker counting data structures.
 inline void ConcurrentMark::count_object(oop obj,
 HeapRegion* hr,
 size_t* marked_bytes_array,
 BitMap* task_card_bm) {
 MemRegion mr((HeapWord*)obj, obj->size());
 count_region(mr, hr, marked_bytes_array, task_card_bm);
-}
-// Counts the given object in the task/worker counting data
-// structures for the given worker id.
-inline void ConcurrentMark::count_object(oop obj,
-HeapRegion* hr,
-uint worker_id) {
-size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id);
-BitMap* task_card_bm = count_card_bitmap_for(worker_id);
-HeapWord* addr = (HeapWord*) obj;
-count_object(obj, hr, marked_bytes_array, task_card_bm);
 }
 // Attempts to mark the given object and, if successful, counts
 // the object in the given task/worker counting structures.
 inline bool ConcurrentMark::par_mark_and_count(oop obj,
 return true;
 }
 return false;
 }
-// Attempts to mark the given object and, if successful, counts
-// the object in the task/worker counting structures for the
-// given worker id.
-inline bool ConcurrentMark::par_mark_and_count(oop obj,
-HeapRegion* hr,
-uint worker_id) {
-HeapWord* addr = (HeapWord*)obj;
-if (_nextMarkBitMap->parMark(addr)) {
-// Update the task specific count data for the object.
-count_object(obj, hr, worker_id);
-return true;
-}
-return false;
-}
-// As above - but we don't know the heap region containing the
-// object and so have to supply it.
-inline bool ConcurrentMark::par_mark_and_count(oop obj, uint worker_id) {
-HeapWord* addr = (HeapWord*)obj;
-HeapRegion* hr = _g1h->heap_region_containing_raw(addr);
-return par_mark_and_count(obj, hr, worker_id);
-}
-// Similar to the above routine but we already know the size, in words, of
-// the object that we wish to mark/count
-inline bool ConcurrentMark::par_mark_and_count(oop obj,
-size_t word_size,
-uint worker_id) {
-HeapWord* addr = (HeapWord*)obj;
-if (_nextMarkBitMap->parMark(addr)) {
-// Update the task specific count data for the object.
-MemRegion mr(addr, word_size);
-count_region(mr, worker_id);
-return true;
-}
-return false;
-}
-// Unconditionally mark the given object, and unconditinally count
-// the object in the counting structures for worker id 0.
-// Should *not* be called from parallel code.
-inline bool ConcurrentMark::mark_and_count(oop obj, HeapRegion* hr) {
-HeapWord* addr = (HeapWord*)obj;
-_nextMarkBitMap->mark(addr);
-// Update the task specific count data for the object.
-count_object(obj, hr, 0 /* worker_id */);
-return true;
-}
-// As above - but we don't have the heap region containing the
-// object, so we have to supply it.
-inline bool ConcurrentMark::mark_and_count(oop obj) {
-HeapWord* addr = (HeapWord*)obj;
-HeapRegion* hr = _g1h->heap_region_containing_raw(addr);
-return mark_and_count(obj, hr);
-}
 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) {
 HeapWord* start_addr = MAX2(startWord(), mr.start());
 HeapWord* end_addr = MIN2(endWord(), mr.end());
 if (end_addr > start_addr) {
 inline bool CMBitMapRO::iterate(BitMapClosure* cl) {
 MemRegion mr(startWord(), sizeInWords());
 return iterate(cl, mr);
 }
+#define check_mark(addr)                                                       \
+assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize),      \
+"outside underlying space?");                                         \
+assert(G1CollectedHeap::heap()->is_in_exact(addr),                           \
+err_msg("Trying to access not available bitmap "PTR_FORMAT            \
+" corresponding to "PTR_FORMAT" (%u)",                        \
+p2i(this), p2i(addr), G1CollectedHeap::heap()->addr_to_region(addr)));
+inline void CMBitMap::mark(HeapWord* addr) {
+check_mark(addr);
+_bm.set_bit(heapWordToOffset(addr));
+}
+inline void CMBitMap::clear(HeapWord* addr) {
+check_mark(addr);
+_bm.clear_bit(heapWordToOffset(addr));
+}
+inline bool CMBitMap::parMark(HeapWord* addr) {
+check_mark(addr);
+return _bm.par_set_bit(heapWordToOffset(addr));
+}
+inline bool CMBitMap::parClear(HeapWord* addr) {
+check_mark(addr);
+return _bm.par_clear_bit(heapWordToOffset(addr));
+}
+#undef check_mark
 inline void CMTask::push(oop obj) {
 HeapWord* objAddr = (HeapWord*) obj;
 assert(_g1h->is_in_g1_reserved(objAddr), "invariant");
 assert(!_g1h->is_on_master_free_list(

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp @ 20804:7848fc12602b