src/share/vm/gc/g1/concurrentMark.cpp

*** 56,140 ****
  #include "runtime/handles.inline.hpp"
  #include "runtime/java.hpp"
  #include "runtime/prefetch.inline.hpp"
  #include "services/memTracker.hpp"
  
! // Concurrent marking bit map wrapper
  
! CMBitMapRO::CMBitMapRO(int shifter) :
!   _bm(),
!   _shifter(shifter) {
!   _bmStartWord = 0;
!   _bmWordSize = 0;
! }
! 
! HeapWord* CMBitMapRO::getNextMarkedWordAddress(const HeapWord* addr,
!                                                const HeapWord* limit) const {
!   // First we must round addr *up* to a possible object boundary.
!   addr = (HeapWord*)align_size_up((intptr_t)addr,
!                                   HeapWordSize << _shifter);
!   size_t addrOffset = heapWordToOffset(addr);
!   if (limit == NULL) {
!     limit = _bmStartWord + _bmWordSize;
!   }
!   size_t limitOffset = heapWordToOffset(limit);
!   size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset);
!   HeapWord* nextAddr = offsetToHeapWord(nextOffset);
!   assert(nextAddr >= addr, "get_next_one postcondition");
!   assert(nextAddr == limit || isMarked(nextAddr),
!          "get_next_one postcondition");
!   return nextAddr;
! }
! 
! HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(const HeapWord* addr,
!                                                  const HeapWord* limit) const {
!   size_t addrOffset = heapWordToOffset(addr);
!   if (limit == NULL) {
!     limit = _bmStartWord + _bmWordSize;
!   }
!   size_t limitOffset = heapWordToOffset(limit);
!   size_t nextOffset = _bm.get_next_zero_offset(addrOffset, limitOffset);
!   HeapWord* nextAddr = offsetToHeapWord(nextOffset);
!   assert(nextAddr >= addr, "get_next_one postcondition");
!   assert(nextAddr == limit || !isMarked(nextAddr),
!          "get_next_one postcondition");
!   return nextAddr;
! }
! 
! int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const {
!   assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
!   return (int) (diff >> _shifter);
! }
! 
! #ifndef PRODUCT
! bool CMBitMapRO::covers(MemRegion heap_rs) const {
!   // assert(_bm.map() == _virtual_space.low(), "map inconsistency");
!   assert(((size_t)_bm.size() * ((size_t)1 << _shifter)) == _bmWordSize,
!          "size inconsistency");
!   return _bmStartWord == (HeapWord*)(heap_rs.start()) &&
!          _bmWordSize  == heap_rs.word_size();
! }
! #endif
! 
! void CMBitMapRO::print_on_error(outputStream* st, const char* prefix) const {
!   _bm.print_on_error(st, prefix);
! }
! 
! size_t CMBitMap::compute_size(size_t heap_size) {
!   return ReservedSpace::allocation_align_size_up(heap_size / mark_distance());
! }
! 
! size_t CMBitMap::mark_distance() {
!   return MinObjAlignmentInBytes * BitsPerByte;
! }
! 
! void CMBitMap::initialize(MemRegion heap, G1RegionToSpaceMapper* storage) {
!   _bmStartWord = heap.start();
!   _bmWordSize = heap.word_size();
! 
!   _bm.set_map((BitMap::bm_word_t*) storage->reserved().start());
!   _bm.set_size(_bmWordSize >> _shifter);
  
    storage->set_mapping_changed_listener(&_listener);
  }
  
  void CMBitMapMappingChangedListener::on_commit(uint start_region, size_t num_regions, bool zero_filled) {
--- 56,68 ----
  #include "runtime/handles.inline.hpp"
  #include "runtime/java.hpp"
  #include "runtime/prefetch.inline.hpp"
  #include "services/memTracker.hpp"
  
! void G1CMBitMap::initialize(MemRegion heap, G1RegionToSpaceMapper* storage) {
  
!   CMBitMap::initialize(heap, storage->reserved());
  
    storage->set_mapping_changed_listener(&_listener);
  }
  
  void CMBitMapMappingChangedListener::on_commit(uint start_region, size_t num_regions, bool zero_filled) {
*** 198,250 ****
      SuspendibleThreadSetJoiner sts_join(_suspendible);
      G1CollectedHeap::heap()->heap_region_par_iterate(_cl, worker_id, &_hrclaimer, true);
    }
  };
  
! void CMBitMap::clearAll() {
    G1CollectedHeap* g1h = G1CollectedHeap::heap();
    ClearBitmapHRClosure cl(NULL, this, false /* may_yield */);
    uint n_workers = g1h->workers()->active_workers();
    ParClearNextMarkBitmapTask task(&cl, n_workers, false);
    g1h->workers()->run_task(&task);
    guarantee(cl.complete(), "Must have completed iteration.");
    return;
  }
  
- void CMBitMap::markRange(MemRegion mr) {
-   mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
-   assert(!mr.is_empty(), "unexpected empty region");
-   assert((offsetToHeapWord(heapWordToOffset(mr.end())) ==
-           ((HeapWord *) mr.end())),
-          "markRange memory region end is not card aligned");
-   // convert address range into offset range
-   _bm.at_put_range(heapWordToOffset(mr.start()),
-                    heapWordToOffset(mr.end()), true);
- }
- 
- void CMBitMap::clearRange(MemRegion mr) {
-   mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
-   assert(!mr.is_empty(), "unexpected empty region");
-   // convert address range into offset range
-   _bm.at_put_range(heapWordToOffset(mr.start()),
-                    heapWordToOffset(mr.end()), false);
- }
- 
- MemRegion CMBitMap::getAndClearMarkedRegion(HeapWord* addr,
-                                             HeapWord* end_addr) {
-   HeapWord* start = getNextMarkedWordAddress(addr);
-   start = MIN2(start, end_addr);
-   HeapWord* end   = getNextUnmarkedWordAddress(start);
-   end = MIN2(end, end_addr);
-   assert(start <= end, "Consistency check");
-   MemRegion mr(start, end);
-   if (!mr.is_empty()) {
-     clearRange(mr);
-   }
-   return mr;
- }
- 
  CMMarkStack::CMMarkStack(ConcurrentMark* cm) :
    _base(NULL), _cm(cm)
  #ifdef ASSERT
    , _drain_in_progress(false)
    , _drain_in_progress_yields(false)
--- 126,145 ----
      SuspendibleThreadSetJoiner sts_join(_suspendible);
      G1CollectedHeap::heap()->heap_region_par_iterate(_cl, worker_id, &_hrclaimer, true);
    }
  };
  
! void G1CMBitMap::clearAll() {
    G1CollectedHeap* g1h = G1CollectedHeap::heap();
    ClearBitmapHRClosure cl(NULL, this, false /* may_yield */);
    uint n_workers = g1h->workers()->active_workers();
    ParClearNextMarkBitmapTask task(&cl, n_workers, false);
    g1h->workers()->run_task(&task);
    guarantee(cl.complete(), "Must have completed iteration.");
    return;
  }
  
  CMMarkStack::CMMarkStack(ConcurrentMark* cm) :
    _base(NULL), _cm(cm)
  #ifdef ASSERT
    , _drain_in_progress(false)
    , _drain_in_progress_yields(false)