< prev index next >

src/share/vm/gc/g1/concurrentMark.inline.hpp

Print this page




  72   // by the card shift -- address 0 corresponds to card number 0.  One
  73   // must subtract the card num of the bottom of the heap to obtain a
  74   // card table index.
  75   intptr_t card_num = intptr_t(uintptr_t(addr) >> CardTableModRefBS::card_shift);
  76   return card_num - heap_bottom_card_num();
  77 }
  78 
  79 // Counts the given memory region in the given task/worker
  80 // counting data structures.
  81 inline void ConcurrentMark::count_region(MemRegion mr, HeapRegion* hr,
  82                                          size_t* marked_bytes_array,
  83                                          BitMap* task_card_bm) {
  84   G1CollectedHeap* g1h = _g1h;
  85   CardTableModRefBS* ct_bs = g1h->g1_barrier_set();
  86 
  87   HeapWord* start = mr.start();
  88   HeapWord* end = mr.end();
  89   size_t region_size_bytes = mr.byte_size();
  90   uint index = hr->hrm_index();
  91 
  92   assert(!hr->is_continues_humongous(), "should not be HC region");
  93   assert(hr == g1h->heap_region_containing(start), "sanity");
  94   assert(hr == g1h->heap_region_containing(mr.last()), "sanity");
  95   assert(marked_bytes_array != NULL, "pre-condition");
  96   assert(task_card_bm != NULL, "pre-condition");
  97 
  98   // Add to the task local marked bytes for this region.
  99   marked_bytes_array[index] += region_size_bytes;
 100 
 101   BitMap::idx_t start_idx = card_bitmap_index_for(start);
 102   BitMap::idx_t end_idx = card_bitmap_index_for(end);
 103 
 104   // Note: if we're looking at the last region in heap - end
 105   // could be actually just beyond the end of the heap; end_idx
 106   // will then correspond to a (non-existent) card that is also
 107   // just beyond the heap.
 108   if (g1h->is_in_g1_reserved(end) && !ct_bs->is_card_aligned(end)) {
 109     // end of region is not card aligned - increment to cover
 110     // all the cards spanned by the region.
 111     end_idx += 1;
 112   }
 113   // The card bitmap is task/worker specific => no need to use
 114   // the 'par' BitMap routines.
 115   // Set bits in the exclusive bit range [start_idx, end_idx).
 116   set_card_bitmap_range(task_card_bm, start_idx, end_idx, false /* is_par */);
 117 }
 118 
 119 // Counts the given memory region in the task/worker counting
 120 // data structures for the given worker id.
 121 inline void ConcurrentMark::count_region(MemRegion mr,
 122                                          HeapRegion* hr,
 123                                          uint worker_id) {
 124   size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id);
 125   BitMap* task_card_bm = count_card_bitmap_for(worker_id);
 126   count_region(mr, hr, marked_bytes_array, task_card_bm);
 127 }
 128 
 129 // Counts the given object in the given task/worker counting data structures.
 130 inline void ConcurrentMark::count_object(oop obj,
 131                                          HeapRegion* hr,
 132                                          size_t* marked_bytes_array,
 133                                          BitMap* task_card_bm) {
 134   MemRegion mr((HeapWord*)obj, obj->size());



 135   count_region(mr, hr, marked_bytes_array, task_card_bm);











 136 }
 137 
 138 // Attempts to mark the given object and, if successful, counts
 139 // the object in the given task/worker counting structures.
 140 inline bool ConcurrentMark::par_mark_and_count(oop obj,
 141                                                HeapRegion* hr,
 142                                                size_t* marked_bytes_array,
 143                                                BitMap* task_card_bm) {
 144   HeapWord* addr = (HeapWord*)obj;
 145   if (_nextMarkBitMap->parMark(addr)) {
 146     // Update the task specific count data for the object.
 147     count_object(obj, hr, marked_bytes_array, task_card_bm);
 148     return true;
 149   }
 150   return false;
 151 }
 152 
 153 // Attempts to mark the given object and, if successful, counts
 154 // the object in the task/worker counting structures for the
 155 // given worker id.
 156 inline bool ConcurrentMark::par_mark_and_count(oop obj,
 157                                                size_t word_size,
 158                                                HeapRegion* hr,
 159                                                uint worker_id) {
 160   HeapWord* addr = (HeapWord*)obj;
 161   if (_nextMarkBitMap->parMark(addr)) {
 162     MemRegion mr(addr, word_size);
 163     count_region(mr, hr, worker_id);
 164     return true;
 165   }
 166   return false;
 167 }
 168 
 169 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) {
 170   HeapWord* start_addr = MAX2(startWord(), mr.start());
 171   HeapWord* end_addr = MIN2(endWord(), mr.end());
 172 
 173   if (end_addr > start_addr) {
 174     // Right-open interval [start-offset, end-offset).
 175     BitMap::idx_t start_offset = heapWordToOffset(start_addr);
 176     BitMap::idx_t end_offset = heapWordToOffset(end_addr);
 177 
 178     start_offset = _bm.get_next_one_offset(start_offset, end_offset);
 179     while (start_offset < end_offset) {
 180       if (!cl->do_bit(start_offset)) {
 181         return false;
 182       }
 183       HeapWord* next_addr = MIN2(nextObject(offsetToHeapWord(start_offset)), end_addr);


 374     }
 375   }
 376 }
 377 
 378 inline void CMTask::deal_with_reference(oop obj) {
 379   if (_cm->verbose_high()) {
 380     gclog_or_tty->print_cr("[%u] we're dealing with reference = " PTR_FORMAT,
 381                            _worker_id, p2i((void*) obj));
 382   }
 383 
 384   increment_refs_reached();
 385 
 386   HeapWord* objAddr = (HeapWord*) obj;
 387   assert(obj->is_oop_or_null(true /* ignore mark word */), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
 388   if (_g1h->is_in_g1_reserved(objAddr)) {
 389     assert(obj != NULL, "null check is implicit");
 390     if (!_nextMarkBitMap->isMarked(objAddr)) {
 391       // Only get the containing region if the object is not marked on the
 392       // bitmap (otherwise, it's a waste of time since we won't do
 393       // anything with it).
 394       HeapRegion* hr = _g1h->heap_region_containing_raw(obj);
 395       if (!hr->obj_allocated_since_next_marking(obj)) {
 396         make_reference_grey(obj, hr);
 397       }
 398     }
 399   }
 400 }
 401 
 402 inline void ConcurrentMark::markPrev(oop p) {
 403   assert(!_prevMarkBitMap->isMarked((HeapWord*) p), "sanity");
 404   // Note we are overriding the read-only view of the prev map here, via
 405   // the cast.
 406   ((CMBitMap*)_prevMarkBitMap)->mark((HeapWord*) p);
 407 }
 408 
 409 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size,
 410                                      uint worker_id, HeapRegion* hr) {
 411   assert(obj != NULL, "pre-condition");
 412   HeapWord* addr = (HeapWord*) obj;
 413   if (hr == NULL) {
 414     hr = _g1h->heap_region_containing_raw(addr);
 415   } else {
 416     assert(hr->is_in(addr), "pre-condition");
 417   }
 418   assert(hr != NULL, "sanity");
 419   // Given that we're looking for a region that contains an object
 420   // header it's impossible to get back a HC region.
 421   assert(!hr->is_continues_humongous(), "sanity");
 422 
 423   // We cannot assert that word_size == obj->size() given that obj
 424   // might not be in a consistent state (another thread might be in
 425   // the process of copying it). So the best thing we can do is to
 426   // assert that word_size is under an upper bound which is its
 427   // containing region's capacity.
 428   assert(word_size * HeapWordSize <= hr->capacity(),
 429          "size: " SIZE_FORMAT " capacity: " SIZE_FORMAT " " HR_FORMAT,
 430          word_size * HeapWordSize, hr->capacity(),
 431          HR_FORMAT_PARAMS(hr));
 432 
 433   if (addr < hr->next_top_at_mark_start()) {
 434     if (!_nextMarkBitMap->isMarked(addr)) {
 435       par_mark_and_count(obj, word_size, hr, worker_id);
 436     }
 437   }
 438 }
 439 
 440 #endif // SHARE_VM_GC_G1_CONCURRENTMARK_INLINE_HPP


  72   // by the card shift -- address 0 corresponds to card number 0.  One
  73   // must subtract the card num of the bottom of the heap to obtain a
  74   // card table index.
  75   intptr_t card_num = intptr_t(uintptr_t(addr) >> CardTableModRefBS::card_shift);
  76   return card_num - heap_bottom_card_num();
  77 }
  78 
  79 // Counts the given memory region in the given task/worker
  80 // counting data structures.
  81 inline void ConcurrentMark::count_region(MemRegion mr, HeapRegion* hr,
  82                                          size_t* marked_bytes_array,
  83                                          BitMap* task_card_bm) {
  84   G1CollectedHeap* g1h = _g1h;
  85   CardTableModRefBS* ct_bs = g1h->g1_barrier_set();
  86 
  87   HeapWord* start = mr.start();
  88   HeapWord* end = mr.end();
  89   size_t region_size_bytes = mr.byte_size();
  90   uint index = hr->hrm_index();
  91 

  92   assert(hr == g1h->heap_region_containing(start), "sanity");

  93   assert(marked_bytes_array != NULL, "pre-condition");
  94   assert(task_card_bm != NULL, "pre-condition");
  95 
  96   // Add to the task local marked bytes for this region.
  97   marked_bytes_array[index] += region_size_bytes;
  98 
  99   BitMap::idx_t start_idx = card_bitmap_index_for(start);
 100   BitMap::idx_t end_idx = card_bitmap_index_for(end);
 101 
 102   // Note: if we're looking at the last region in heap - end
 103   // could be actually just beyond the end of the heap; end_idx
 104   // will then correspond to a (non-existent) card that is also
 105   // just beyond the heap.
 106   if (g1h->is_in_g1_reserved(end) && !ct_bs->is_card_aligned(end)) {
 107     // end of region is not card aligned - increment to cover
 108     // all the cards spanned by the region.
 109     end_idx += 1;
 110   }
 111   // The card bitmap is task/worker specific => no need to use
 112   // the 'par' BitMap routines.
 113   // Set bits in the exclusive bit range [start_idx, end_idx).
 114   set_card_bitmap_range(task_card_bm, start_idx, end_idx, false /* is_par */);
 115 }
 116 










 117 // Counts the given object in the given task/worker counting data structures.
 118 inline void ConcurrentMark::count_object(oop obj,
 119                                          HeapRegion* hr,
 120                                          size_t* marked_bytes_array,
 121                                          BitMap* task_card_bm,
 122                                          size_t word_size) {
 123   assert(!hr->is_continues_humongous(), "Cannot enter count_object with continues humongous");
 124   if (!hr->is_starts_humongous()) {
 125     MemRegion mr((HeapWord*)obj, word_size);
 126     count_region(mr, hr, marked_bytes_array, task_card_bm);
 127   } else {
 128     uint index = hr->hrm_index();
 129     do {
 130       MemRegion mr(hr->bottom(), hr->top());
 131       count_region(mr, hr, marked_bytes_array, task_card_bm);
 132       if (++index >= _g1h->num_regions()) {
 133         break;
 134       }
 135       hr = _g1h->region_at(index);
 136     } while (hr->is_continues_humongous());
 137   }
 138 }
 139 
 140 // Attempts to mark the given object and, if successful, counts
 141 // the object in the given task/worker counting structures.
 142 inline bool ConcurrentMark::par_mark_and_count(oop obj,
 143                                                HeapRegion* hr,
 144                                                size_t* marked_bytes_array,
 145                                                BitMap* task_card_bm) {
 146   if (_nextMarkBitMap->parMark((HeapWord*)obj)) {

 147     // Update the task specific count data for the object.
 148     count_object(obj, hr, marked_bytes_array, task_card_bm, obj->size());
 149     return true;
 150   }
 151   return false;
 152 }
 153 
 154 // Attempts to mark the given object and, if successful, counts
 155 // the object in the task/worker counting structures for the
 156 // given worker id.
 157 inline bool ConcurrentMark::par_mark_and_count(oop obj,
 158                                                size_t word_size,
 159                                                HeapRegion* hr,
 160                                                uint worker_id) {
 161   if (_nextMarkBitMap->parMark((HeapWord*)obj)) {
 162     size_t* marked_bytes_array = count_marked_bytes_array_for(worker_id);
 163     BitMap* task_card_bm = count_card_bitmap_for(worker_id);
 164     count_object(obj, hr, marked_bytes_array, task_card_bm, word_size);
 165     return true;
 166   }
 167   return false;
 168 }
 169 
 170 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) {
 171   HeapWord* start_addr = MAX2(startWord(), mr.start());
 172   HeapWord* end_addr = MIN2(endWord(), mr.end());
 173 
 174   if (end_addr > start_addr) {
 175     // Right-open interval [start-offset, end-offset).
 176     BitMap::idx_t start_offset = heapWordToOffset(start_addr);
 177     BitMap::idx_t end_offset = heapWordToOffset(end_addr);
 178 
 179     start_offset = _bm.get_next_one_offset(start_offset, end_offset);
 180     while (start_offset < end_offset) {
 181       if (!cl->do_bit(start_offset)) {
 182         return false;
 183       }
 184       HeapWord* next_addr = MIN2(nextObject(offsetToHeapWord(start_offset)), end_addr);


 375     }
 376   }
 377 }
 378 
 379 inline void CMTask::deal_with_reference(oop obj) {
 380   if (_cm->verbose_high()) {
 381     gclog_or_tty->print_cr("[%u] we're dealing with reference = " PTR_FORMAT,
 382                            _worker_id, p2i((void*) obj));
 383   }
 384 
 385   increment_refs_reached();
 386 
 387   HeapWord* objAddr = (HeapWord*) obj;
 388   assert(obj->is_oop_or_null(true /* ignore mark word */), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
 389   if (_g1h->is_in_g1_reserved(objAddr)) {
 390     assert(obj != NULL, "null check is implicit");
 391     if (!_nextMarkBitMap->isMarked(objAddr)) {
 392       // Only get the containing region if the object is not marked on the
 393       // bitmap (otherwise, it's a waste of time since we won't do
 394       // anything with it).
 395       HeapRegion* hr = _g1h->heap_region_containing(obj);
 396       if (!hr->obj_allocated_since_next_marking(obj)) {
 397         make_reference_grey(obj, hr);
 398       }
 399     }
 400   }
 401 }
 402 
 403 inline void ConcurrentMark::markPrev(oop p) {
 404   assert(!_prevMarkBitMap->isMarked((HeapWord*) p), "sanity");
 405   // Note we are overriding the read-only view of the prev map here, via
 406   // the cast.
 407   ((CMBitMap*)_prevMarkBitMap)->mark((HeapWord*) p);
 408 }
 409 
 410 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size,
 411                                      uint worker_id, HeapRegion* hr) {
 412   assert(obj != NULL, "pre-condition");
 413   HeapWord* addr = (HeapWord*) obj;
 414   if (hr == NULL) {
 415     hr = _g1h->heap_region_containing(addr);
 416   } else {
 417     assert(hr->is_in(addr), "pre-condition");
 418   }
 419   assert(hr != NULL, "sanity");
 420   // Given that we're looking for a region that contains an object
 421   // header it's impossible to get back a HC region.
 422   assert(!hr->is_continues_humongous(), "sanity");










 423 
 424   if (addr < hr->next_top_at_mark_start()) {
 425     if (!_nextMarkBitMap->isMarked(addr)) {
 426       par_mark_and_count(obj, word_size, hr, worker_id);
 427     }
 428   }
 429 }
 430 
 431 #endif // SHARE_VM_GC_G1_CONCURRENTMARK_INLINE_HPP
< prev index next >