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

rev 13047 : imported patch 8071280-specialize-heapregion-oops-on-card-seq-iterate
rev 13048 : imported patch 8071280-kim-review
rev 13049 : imported patch 8071280-kim-sangheon-review
rev 13050 : imported patch 8071280-erikh-review

*** 110,134 ****
  inline HeapWord*
  G1ContiguousSpace::block_start_const(const void* p) const {
    return _bot_part.block_start_const(p);
  }
  
! template <bool is_gc_active>
! inline bool HeapRegion::is_obj_dead_with_size(const oop obj, G1CMBitMapRO* bitmap, size_t* size) const {
    assert(!is_archive(), "Archive regions should not have references into interesting regions.");
    assert(!is_humongous(), "Humongous objects not handled here");
!   bool result =
!     !obj_allocated_since_prev_marking(obj) &&
!     !bitmap->isMarked((HeapWord*)obj);
!   if (ClassUnloadingWithConcurrentMark && result) {
!     *size = is_gc_active ? block_size_during_gc((HeapWord*)obj, bitmap)
!                          : block_size((HeapWord*)obj);
    } else {
!     assert(block_is_obj((HeapWord*)obj), "must be");
      *size = obj->size();
    }
!   return result;
  }
  
  inline bool
  HeapRegion::block_is_obj(const HeapWord* p) const {
    G1CollectedHeap* g1h = G1CollectedHeap::heap();
--- 110,135 ----
  inline HeapWord*
  G1ContiguousSpace::block_start_const(const void* p) const {
    return _bot_part.block_start_const(p);
  }
  
! inline bool HeapRegion::is_obj_dead_with_size(const oop obj, G1CMBitMapRO* prev_bitmap, size_t* size) const {
!   HeapWord* addr = (HeapWord*) obj;
! 
!   assert(addr < top(), "must be");
    assert(!is_archive(), "Archive regions should not have references into interesting regions.");
    assert(!is_humongous(), "Humongous objects not handled here");
!   bool obj_is_dead = is_obj_dead(obj, prev_bitmap);
! 
!   if (ClassUnloadingWithConcurrentMark && obj_is_dead) {
!     assert(!block_is_obj(addr), "must be");
!     *size = block_size_using_bitmap(addr, prev_bitmap);
    } else {
!     assert(block_is_obj(addr), "must be");
      *size = obj->size();
    }
!   return obj_is_dead;
  }
  
  inline bool
  HeapRegion::block_is_obj(const HeapWord* p) const {
    G1CollectedHeap* g1h = G1CollectedHeap::heap();
*** 141,170 ****
      return !g1h->is_obj_dead(oop(p), this);
    }
    return p < top();
  }
  
! inline size_t HeapRegion::block_size_using_bitmap(const HeapWord* addr, const G1CMBitMapRO* bitmap) const {
    assert(ClassUnloadingWithConcurrentMark,
           "All blocks should be objects if class unloading isn't used, so this method should not be called. "
           "HR: [" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT ") "
           "addr: " PTR_FORMAT,
           p2i(bottom()), p2i(top()), p2i(end()), p2i(addr));
  
    // Old regions' dead objects may have dead classes
    // We need to find the next live object using the bitmap
!   HeapWord* next = bitmap->getNextMarkedWordAddress(addr, prev_top_at_mark_start());
  
    assert(next > addr, "must get the next live object");
    return pointer_delta(next, addr);    
  }
  
! inline size_t HeapRegion::block_size_during_gc(const HeapWord *addr, const G1CMBitMapRO* bitmap) const {
!   assert(addr < top(), "must be");
!   assert(!block_is_obj(addr), "must be");
! 
!   return block_size_using_bitmap(addr, bitmap);
  }
  
  inline size_t HeapRegion::block_size(const HeapWord *addr) const {
    if (addr == top()) {
      return pointer_delta(end(), addr);
--- 142,169 ----
      return !g1h->is_obj_dead(oop(p), this);
    }
    return p < top();
  }
  
! inline size_t HeapRegion::block_size_using_bitmap(const HeapWord* addr, const G1CMBitMapRO* prev_bitmap) const {
    assert(ClassUnloadingWithConcurrentMark,
           "All blocks should be objects if class unloading isn't used, so this method should not be called. "
           "HR: [" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT ") "
           "addr: " PTR_FORMAT,
           p2i(bottom()), p2i(top()), p2i(end()), p2i(addr));
  
    // Old regions' dead objects may have dead classes
    // We need to find the next live object using the bitmap
!   HeapWord* next = prev_bitmap->getNextMarkedWordAddress(addr, prev_top_at_mark_start());
  
    assert(next > addr, "must get the next live object");
    return pointer_delta(next, addr);    
  }
  
! inline bool HeapRegion::is_obj_dead(const oop obj, const G1CMBitMapRO* prev_bitmap) const {
!   assert(is_in_reserved(obj), "Object " PTR_FORMAT " must be in region", p2i(obj));
!   return !obj_allocated_since_prev_marking(obj) && !prev_bitmap->isMarked((HeapWord*)obj);
  }
  
  inline size_t HeapRegion::block_size(const HeapWord *addr) const {
    if (addr == top()) {
      return pointer_delta(end(), addr);
*** 337,347 ****
      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));
  
      size_t size;
!     bool is_dead = is_obj_dead_with_size<is_gc_active>(obj, bitmap, &size);
  
      cur += size;
      if (!is_dead) {
        // Process live object's references.
  
--- 336,346 ----
      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));
  
      size_t size;
!     bool is_dead = is_obj_dead_with_size(obj, bitmap, &size);
  
      cur += size;
      if (!is_dead) {
        // Process live object's references.