8329203: Parallel: Investigate Mark-Compact for Full GC to decrease memory usage

Reviewed-by: rkennke, gli

Author: albertnetymk

src/hotspot/share/gc/parallel/parMarkBitMap.cpp

@@ -37,9 +37,6 @@ bool
 ParMarkBitMap::initialize(MemRegion covered_region)
 {
   const idx_t bits = bits_required(covered_region);
-  // The bits will be divided evenly between two bitmaps; each of them should be
-  // an integral number of words.
-  assert(is_aligned(bits, (BitsPerWord * 2)), "region size unaligned");
 
   const size_t words = bits / BitsPerWord;
   const size_t raw_bytes = words * sizeof(idx_t);
@@ -61,8 +58,7 @@ ParMarkBitMap::initialize(MemRegion covered_region)
     _region_start = covered_region.start();
     _region_size = covered_region.word_size();
     BitMap::bm_word_t* map = (BitMap::bm_word_t*)_virtual_space->reserved_low_addr();
-    _beg_bits = BitMapView(map,             bits / 2);
-    _end_bits = BitMapView(map + words / 2, bits / 2);
+    _beg_bits = BitMapView(map, bits);
     return true;
   }
 
@@ -77,176 +73,6 @@ ParMarkBitMap::initialize(MemRegion covered_region)
   return false;
 }
 
-bool
-ParMarkBitMap::mark_obj(HeapWord* addr, size_t size)
-{
-  const idx_t beg_bit = addr_to_bit(addr);
-  if (_beg_bits.par_set_bit(beg_bit)) {
-    const idx_t end_bit = addr_to_bit(addr + size - 1);
-    bool end_bit_ok = _end_bits.par_set_bit(end_bit);
-    assert(end_bit_ok, "concurrency problem");
-    return true;
-  }
-  return false;
-}
-
-inline bool
-ParMarkBitMap::is_live_words_in_range_in_cache(ParCompactionManager* cm, HeapWord* beg_addr) const {
-  return cm->last_query_begin() == beg_addr;
-}
-
-inline void
-ParMarkBitMap::update_live_words_in_range_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj, size_t result) const {
-  cm->set_last_query_begin(beg_addr);
-  cm->set_last_query_object(end_obj);
-  cm->set_last_query_return(result);
-}
-
-size_t
-ParMarkBitMap::live_words_in_range_helper(HeapWord* beg_addr, oop end_obj) const
-{
-  assert(beg_addr <= cast_from_oop<HeapWord*>(end_obj), "bad range");
-  assert(is_marked(end_obj), "end_obj must be live");
-
-  idx_t live_bits = 0;
-
-  // The bitmap routines require the right boundary to be word-aligned.
-  const idx_t end_bit = addr_to_bit(cast_from_oop<HeapWord*>(end_obj));
-  const idx_t range_end = align_range_end(end_bit);
-
-  idx_t beg_bit = find_obj_beg(addr_to_bit(beg_addr), range_end);
-  while (beg_bit < end_bit) {
-    idx_t tmp_end = find_obj_end(beg_bit, range_end);
-    assert(tmp_end < end_bit, "missing end bit");
-    live_bits += tmp_end - beg_bit + 1;
-    beg_bit = find_obj_beg(tmp_end + 1, range_end);
-  }
-  return bits_to_words(live_bits);
-}
-
-size_t
-ParMarkBitMap::live_words_in_range_use_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_oop) const
-{
-  HeapWord* last_beg = cm->last_query_begin();
-  HeapWord* last_obj = cast_from_oop<HeapWord*>(cm->last_query_object());
-  HeapWord* end_obj  = cast_from_oop<HeapWord*>(end_oop);
-
-  size_t last_ret = cm->last_query_return();
-  if (end_obj > last_obj) {
-    last_ret = last_ret + live_words_in_range_helper(last_obj, end_oop);
-    last_obj = end_obj;
-  } else if (end_obj < last_obj) {
-    // The cached value is for an object that is to the left (lower address) of the current
-    // end_obj. Calculate back from that cached value.
-    if (pointer_delta(end_obj, beg_addr) > pointer_delta(last_obj, end_obj)) {
-      last_ret = last_ret - live_words_in_range_helper(end_obj, cast_to_oop(last_obj));
-    } else {
-      last_ret = live_words_in_range_helper(beg_addr, end_oop);
-    }
-    last_obj = end_obj;
-  }
-
-  update_live_words_in_range_cache(cm, last_beg, cast_to_oop(last_obj), last_ret);
-  return last_ret;
-}
-
-size_t
-ParMarkBitMap::live_words_in_range(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const
-{
-  // Try to reuse result from ParCompactionManager cache first.
-  if (is_live_words_in_range_in_cache(cm, beg_addr)) {
-    return live_words_in_range_use_cache(cm, beg_addr, end_obj);
-  }
-  size_t ret = live_words_in_range_helper(beg_addr, end_obj);
-  update_live_words_in_range_cache(cm, beg_addr, end_obj, ret);
-  return ret;
-}
-
-ParMarkBitMap::IterationStatus
-ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
-                       idx_t range_beg, idx_t range_end) const
-{
-  DEBUG_ONLY(verify_bit(range_beg);)
-  DEBUG_ONLY(verify_bit(range_end);)
-  assert(range_beg <= range_end, "live range invalid");
-
-  // The bitmap routines require the right boundary to be word-aligned.
-  const idx_t search_end = align_range_end(range_end);
-
-  idx_t cur_beg = range_beg;
-  while (true) {
-    cur_beg = find_obj_beg(cur_beg, search_end);
-    if (cur_beg >= range_end) {
-      break;
-    }
-
-    const size_t size = obj_size(cur_beg);
-    IterationStatus status = live_closure->do_addr(bit_to_addr(cur_beg), size);
-    if (status != incomplete) {
-      assert(status == would_overflow || status == full, "sanity");
-      return status;
-    }
-
-    cur_beg += words_to_bits(size);
-    if (cur_beg >= range_end) {
-      break;
-    }
-  }
-
-  return complete;
-}
-
-ParMarkBitMap::IterationStatus
-ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure,
-                       ParMarkBitMapClosure* dead_closure,
-                       idx_t range_beg, idx_t range_end,
-                       idx_t dead_range_end) const
-{
-  DEBUG_ONLY(verify_bit(range_beg);)
-  DEBUG_ONLY(verify_bit(range_end);)
-  DEBUG_ONLY(verify_bit(dead_range_end);)
-  assert(range_beg <= range_end, "live range invalid");
-  assert(range_end <= dead_range_end, "dead range invalid");
-
-  // The bitmap routines require the right boundary to be word-aligned.
-  const idx_t dead_search_end = align_range_end(dead_range_end);
-
-  idx_t cur_beg = range_beg;
-  if (range_beg < range_end && is_unmarked(range_beg)) {
-    // The range starts with dead space.  Look for the next object, then fill.
-    // This must be the beginning of old/eden/from/to-space, so it's must be
-    // large enough for a filler.
-    cur_beg = find_obj_beg(range_beg + 1, dead_search_end);
-    const idx_t dead_space_end = cur_beg - 1;
-    const size_t size = obj_size(range_beg, dead_space_end);
-    dead_closure->do_addr(bit_to_addr(range_beg), size);
-  }
-
-  while (cur_beg < range_end) {
-    const size_t size = obj_size(cur_beg);
-    IterationStatus status = live_closure->do_addr(bit_to_addr(cur_beg), size);
-    if (status != incomplete) {
-      assert(status == would_overflow || status == full, "sanity");
-      return status;
-    }
-
-    const idx_t dead_space_beg = cur_beg + words_to_bits(size);
-    if (dead_space_beg >= dead_search_end) {
-      break;
-    }
-    // Look for the start of the next object.
-    cur_beg = find_obj_beg(dead_space_beg, dead_search_end);
-    if (cur_beg > dead_space_beg) {
-      // Found dead space; compute the size and invoke the dead closure.
-      const idx_t dead_space_end = cur_beg - 1;
-      dead_closure->do_addr(bit_to_addr(dead_space_beg),
-                            obj_size(dead_space_beg, dead_space_end));
-    }
-  }
-
-  return complete;
-}
-
 #ifdef ASSERT
 void ParMarkBitMap::verify_clear() const
 {

src/hotspot/share/gc/parallel/parMarkBitMap.hpp

@@ -39,18 +39,14 @@ class ParMarkBitMap: public CHeapObj<mtGC>
   typedef BitMap::idx_t idx_t;
 
   // Values returned by the iterate() methods.
-  enum IterationStatus { incomplete, complete, full, would_overflow };
+  enum IterationStatus { incomplete, complete, full };
 
   inline ParMarkBitMap();
   bool initialize(MemRegion covered_region);
 
   // Atomically mark an object as live.
-  bool mark_obj(HeapWord* addr, size_t size);
-  inline bool mark_obj(oop obj, size_t size);
-
-  // Return whether the specified begin or end bit is set.
-  inline bool is_obj_beg(idx_t bit) const;
-  inline bool is_obj_end(idx_t bit) const;
+  inline bool mark_obj(HeapWord* addr);
+  inline bool mark_obj(oop obj);
 
   // Traditional interface for testing whether an object is marked or not (these
   // test only the begin bits).
@@ -68,61 +64,6 @@ class ParMarkBitMap: public CHeapObj<mtGC>
   inline static size_t bits_to_words(idx_t bits);
   inline static idx_t  words_to_bits(size_t words);
 
-  // Return the size in words of an object given a begin bit and an end bit, or
-  // the equivalent beg_addr and end_addr.
-  inline size_t obj_size(idx_t beg_bit, idx_t end_bit) const;
-  inline size_t obj_size(HeapWord* beg_addr, HeapWord* end_addr) const;
-
-  // Return the size in words of the object (a search is done for the end bit).
-  inline size_t obj_size(idx_t beg_bit)  const;
-  inline size_t obj_size(HeapWord* addr) const;
-
-  // Apply live_closure to each live object that lies completely within the
-  // range [live_range_beg, live_range_end).  This is used to iterate over the
-  // compacted region of the heap.  Return values:
-  //
-  // complete           The iteration is complete.  All objects in the range
-  //                    were processed and the closure is not full;
-  //                    closure->source() is set one past the end of the range.
-  //
-  // full               The closure is full; closure->source() is set to one
-  //                    past the end of the last object processed.
-  //
-  // would_overflow     The next object in the range would overflow the closure;
-  //                    closure->source() is set to the start of that object.
-  IterationStatus iterate(ParMarkBitMapClosure* live_closure,
-                          idx_t range_beg, idx_t range_end) const;
-  inline IterationStatus iterate(ParMarkBitMapClosure* live_closure,
-                                 HeapWord* range_beg,
-                                 HeapWord* range_end) const;
-
-  // Apply live closure as above and additionally apply dead_closure to all dead
-  // space in the range [range_beg, dead_range_end).  Note that dead_range_end
-  // must be >= range_end.  This is used to iterate over the dense prefix.
-  //
-  // This method assumes that if the first bit in the range (range_beg) is not
-  // marked, then dead space begins at that point and the dead_closure is
-  // applied.  Thus callers must ensure that range_beg is not in the middle of a
-  // live object.
-  IterationStatus iterate(ParMarkBitMapClosure* live_closure,
-                          ParMarkBitMapClosure* dead_closure,
-                          idx_t range_beg, idx_t range_end,
-                          idx_t dead_range_end) const;
-  inline IterationStatus iterate(ParMarkBitMapClosure* live_closure,
-                                 ParMarkBitMapClosure* dead_closure,
-                                 HeapWord* range_beg,
-                                 HeapWord* range_end,
-                                 HeapWord* dead_range_end) const;
-
-  // Return the number of live words in the range [beg_addr, end_obj) due to
-  // objects that start in the range.  If a live object extends onto the range,
-  // the caller must detect and account for any live words due to that object.
-  // If a live object extends beyond the end of the range, only the words within
-  // the range are included in the result. The end of the range must be a live object,
-  // which is the case when updating pointers.  This allows a branch to be removed
-  // from inside the loop.
-  size_t live_words_in_range(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const;
-
   inline HeapWord* region_start() const;
   inline HeapWord* region_end() const;
   inline size_t    region_size() const;
@@ -141,11 +82,12 @@ class ParMarkBitMap: public CHeapObj<mtGC>
   // respectively) in the range [beg, end).  If no object is found, return end.
   // end must be word-aligned.
   inline idx_t find_obj_beg(idx_t beg, idx_t end) const;
-  inline idx_t find_obj_end(idx_t beg, idx_t end) const;
 
   inline HeapWord* find_obj_beg(HeapWord* beg, HeapWord* end) const;
-  inline HeapWord* find_obj_end(HeapWord* beg, HeapWord* end) const;
 
+  // Return the address of the last obj-start in the range [beg, end).  If no
+  // object is found, return end.
+  inline HeapWord* find_obj_beg_reverse(HeapWord* beg, HeapWord* end) const;
   // Clear a range of bits or the entire bitmap (both begin and end bits are
   // cleared).
   inline void clear_range(idx_t beg, idx_t end);
@@ -158,7 +100,6 @@ class ParMarkBitMap: public CHeapObj<mtGC>
   void print_on_error(outputStream* st) const {
     st->print_cr("Marking Bits: (ParMarkBitMap*) " PTR_FORMAT, p2i(this));
     _beg_bits.print_on_error(st, " Begin Bits: ");
-    _end_bits.print_on_error(st, " End Bits:   ");
   }
 
 #ifdef  ASSERT
@@ -168,11 +109,6 @@ class ParMarkBitMap: public CHeapObj<mtGC>
 #endif  // #ifdef ASSERT
 
 private:
-  size_t live_words_in_range_helper(HeapWord* beg_addr, oop end_obj) const;
-
-  bool is_live_words_in_range_in_cache(ParCompactionManager* cm, HeapWord* beg_addr) const;
-  size_t live_words_in_range_use_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj) const;
-  void update_live_words_in_range_cache(ParCompactionManager* cm, HeapWord* beg_addr, oop end_obj, size_t result) const;
 
   // Each bit in the bitmap represents one unit of 'object granularity.' Objects
   // are double-word aligned in 32-bit VMs, but not in 64-bit VMs, so the 32-bit
@@ -183,7 +119,6 @@ class ParMarkBitMap: public CHeapObj<mtGC>
   HeapWord*       _region_start;
   size_t          _region_size;
   BitMapView      _beg_bits;
-  BitMapView      _end_bits;
   PSVirtualSpace* _virtual_space;
   size_t          _reserved_byte_size;
 };