src/share/vm/gc/shenandoah/shenandoahHeap.inline.hpp

rev 14453 : Remove secondary marking bitmap.

@@ -61,11 +61,11 @@
 /*
  * 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 {
+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,26 +74,21 @@
     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);
+  return mark_no_checks(obj);
 }
 
-inline bool ShenandoahHeap::mark_next_no_checks(oop obj) const {
+inline bool ShenandoahHeap::mark_no_checks(oop obj) {
   HeapWord* addr = (HeapWord*) obj;
-  return (! allocated_after_next_mark_start(addr)) && _next_mark_bit_map->parMark(addr);
+  return !allocated_after_mark_start(addr) && _mark_bit_map.parMark(addr);
 }
 
-inline bool ShenandoahHeap::is_marked_next(oop obj) const {
+inline bool ShenandoahHeap::is_marked(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);
+  return allocated_after_mark_start(addr) || _mark_bit_map.isMarked(addr);
 }
 
 inline bool ShenandoahHeap::need_update_refs() const {
   return _need_update_refs;
 }

@@ -426,11 +421,11 @@
   if (is_concurrent_partial_in_progress()) {
     assert(! in_collection_set((oop) entry), "must not get cset objects here");
     // assert(free_regions()->contains(heap_region_containing(entry)), "expect to-space object");
     return true;
   } else if (concurrent_mark_in_progress()) {
-    return ! is_marked_next(oop(entry));
+    return ! is_marked(oop(entry));
   } else {
     return false;
   }
 }
 

@@ -470,20 +465,13 @@
 
 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 {
+inline bool ShenandoahHeap::allocated_after_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];
+  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>

@@ -499,20 +487,21 @@
 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 = _complete_mark_bit_map;
-  HeapWord* top_at_mark_start = complete_top_at_mark_start(region->bottom());
+  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(top_at_mark_start + BrooksPointer::word_size(), region->end());
-  HeapWord* addr = mark_bit_map->getNextMarkedWordAddress(start, end);
+  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

@@ -535,53 +524,52 @@
       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) {
+        if (addr < tams) {
           addr += skip_bitmap_delta;
-          addr = mark_bit_map->getNextMarkedWordAddress(addr, end);
+          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]);
+        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(mark_bit_map, cl, obj);
+      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(mark_bit_map, cl, obj);
+      do_marked_object(cl, obj);
       addr += size + skip_objsize_delta;
-      if (addr < top_at_mark_start) {
-        addr = mark_bit_map->getNextMarkedWordAddress(addr, end);
+      if (addr < tams) {
+        addr = mark_bit_map.getNextMarkedWordAddress(addr, end);
       }
     }
   }
 }
 
 template<class T>
-inline void ShenandoahHeap::do_marked_object(MarkBitMap* bitmap, T* cl, oop obj) {
+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(bitmap == _complete_mark_bit_map, "only iterate completed mark bitmap");
-  assert(is_marked_complete(obj), "object expected to be marked");
+  assert(is_marked(obj), "object expected to be marked");
   cl->do_object(obj);
 }
 
 template <class T>
 class ShenandoahObjectToOopClosure : public ObjectClosure {