8318647: Serial: Refactor BlockOffsetTable

Reviewed-by: tschatzl, iwalulya

Author: albertnetymk

src/hotspot/share/gc/serial/serialBlockOffsetTable.cpp

@@ -27,24 +27,7 @@
 
 #include "gc/serial/serialBlockOffsetTable.hpp"
 
-#include "gc/shared/space.hpp"
-#include "runtime/safepoint.hpp"
-
-//////////////////////////////////////////////////////////////////////////
-// BlockOffsetTable inlines
-//////////////////////////////////////////////////////////////////////////
-inline HeapWord* BlockOffsetTable::block_start(const void* addr) const {
-  if (addr >= _bottom && addr < _end) {
-    return block_start_unsafe(addr);
-  } else {
-    return nullptr;
-  }
-}
-
-//////////////////////////////////////////////////////////////////////////
-// BlockOffsetSharedArray inlines
-//////////////////////////////////////////////////////////////////////////
-inline size_t BlockOffsetSharedArray::index_for(const void* p) const {
+inline size_t SerialBlockOffsetSharedArray::index_for(const void* p) const {
   char* pc = (char*)p;
   assert(pc >= (char*)_reserved.start() &&
          pc <  (char*)_reserved.end(),
@@ -55,18 +38,12 @@ inline size_t BlockOffsetSharedArray::index_for(const void* p) const {
   return result;
 }
 
-inline HeapWord* BlockOffsetSharedArray::address_for_index(size_t index) const {
+inline HeapWord* SerialBlockOffsetSharedArray::address_for_index(size_t index) const {
   assert(index < _vs.committed_size(), "bad index");
   HeapWord* result = _reserved.start() + (index << BOTConstants::log_card_size_in_words());
   assert(result >= _reserved.start() && result < _reserved.end(),
          "bad address from index");
   return result;
 }
 
-inline void BlockOffsetSharedArray::check_reducing_assertion(bool reducing) {
-    assert(reducing || !SafepointSynchronize::is_at_safepoint() || init_to_zero() ||
-           Thread::current()->is_VM_thread() ||
-           Thread::current()->is_ConcurrentGC_thread(), "Crack");
-}
-
 #endif // SHARE_GC_SERIAL_SERIALBLOCKOFFSETTABLE_INLINE_HPP

src/hotspot/share/gc/serial/serialBlockOffsetTable.hpp

@@ -295,8 +295,8 @@ TenuredGeneration::TenuredGeneration(ReservedSpace rs,
   assert((uintptr_t(start) & 3) == 0, "bad alignment");
   assert((reserved_byte_size & 3) == 0, "bad alignment");
   MemRegion reserved_mr(start, heap_word_size(reserved_byte_size));
-  _bts = new BlockOffsetSharedArray(reserved_mr,
-                                    heap_word_size(initial_byte_size));
+  _bts = new SerialBlockOffsetSharedArray(reserved_mr,
+                                          heap_word_size(initial_byte_size));
   MemRegion committed_mr(start, heap_word_size(initial_byte_size));
   _rs->resize_covered_region(committed_mr);
 
@@ -474,11 +474,10 @@ void TenuredGeneration::object_iterate(ObjectClosure* blk) {
 void TenuredGeneration::complete_loaded_archive_space(MemRegion archive_space) {
   // Create the BOT for the archive space.
   TenuredSpace* space = _the_space;
-  space->initialize_threshold();
   HeapWord* start = archive_space.start();
   while (start < archive_space.end()) {
     size_t word_size = cast_to_oop(start)->size();;
-    space->alloc_block(start, start + word_size);
+    space->update_for_block(start, start + word_size);
     start += word_size;
   }
 }

src/hotspot/share/gc/serial/serialBlockOffsetTable.inline.hpp

@@ -31,7 +31,7 @@
 #include "gc/shared/generationCounters.hpp"
 #include "utilities/macros.hpp"
 
-class BlockOffsetSharedArray;
+class SerialBlockOffsetSharedArray;
 class CardTableRS;
 class ContiguousSpace;
 
@@ -50,7 +50,7 @@ class TenuredGeneration: public Generation {
   // This is shared with other generations.
   CardTableRS* _rs;
   // This is local to this generation.
-  BlockOffsetSharedArray* _bts;
+  SerialBlockOffsetSharedArray* _bts;
 
   // Current shrinking effect: this damps shrinking when the heap gets empty.
   size_t _shrink_factor;

src/hotspot/share/gc/serial/tenuredGeneration.cpp

@@ -29,38 +29,31 @@
 #include "gc/serial/serialHeap.hpp"
 #include "gc/serial/tenuredGeneration.hpp"
 
-#define VM_STRUCTS_SERIALGC(nonstatic_field,                                                    \
-                            volatile_nonstatic_field,                                           \
-                            static_field)                                                       \
-  nonstatic_field(TenuredGeneration,           _rs,                    CardTableRS*)            \
-  nonstatic_field(TenuredGeneration,           _bts,                   BlockOffsetSharedArray*) \
-  nonstatic_field(TenuredGeneration,           _shrink_factor,         size_t)                  \
-  nonstatic_field(TenuredGeneration,           _capacity_at_prologue,  size_t)                  \
-  nonstatic_field(TenuredGeneration,           _used_at_prologue,      size_t)                  \
-  nonstatic_field(TenuredGeneration,           _min_heap_delta_bytes,  size_t)                  \
-  nonstatic_field(TenuredGeneration,           _the_space,             TenuredSpace*)           \
-                                                                                                \
-  nonstatic_field(DefNewGeneration,            _old_gen,               Generation*)             \
-  nonstatic_field(DefNewGeneration,            _tenuring_threshold,    uint)                    \
-  nonstatic_field(DefNewGeneration,            _age_table,             AgeTable)                \
-  nonstatic_field(DefNewGeneration,            _eden_space,            ContiguousSpace*)        \
-  nonstatic_field(DefNewGeneration,            _from_space,            ContiguousSpace*)        \
-  nonstatic_field(DefNewGeneration,            _to_space,              ContiguousSpace*)        \
-                                                                                                \
-  nonstatic_field(BlockOffsetTable,            _bottom,                HeapWord*)               \
-  nonstatic_field(BlockOffsetTable,            _end,                   HeapWord*)               \
-                                                                                                \
-  nonstatic_field(BlockOffsetSharedArray,      _reserved,              MemRegion)               \
-  nonstatic_field(BlockOffsetSharedArray,      _end,                   HeapWord*)               \
-  nonstatic_field(BlockOffsetSharedArray,      _vs,                    VirtualSpace)            \
-  nonstatic_field(BlockOffsetSharedArray,      _offset_array,          u_char*)                 \
-                                                                                                \
-  nonstatic_field(BlockOffsetArray,            _array,                 BlockOffsetSharedArray*) \
-  nonstatic_field(BlockOffsetArray,            _sp,                    Space*)                  \
-  nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_threshold, HeapWord*)               \
-  nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_index,     size_t)                  \
-                                                                                                \
-  nonstatic_field(TenuredSpace,                _offsets,               BlockOffsetArray)
+#define VM_STRUCTS_SERIALGC(nonstatic_field,                                                                \
+                            volatile_nonstatic_field,                                                       \
+                            static_field)                                                                   \
+  nonstatic_field(TenuredGeneration,                 _rs,                    CardTableRS*)                  \
+  nonstatic_field(TenuredGeneration,                 _bts,                   SerialBlockOffsetSharedArray*) \
+  nonstatic_field(TenuredGeneration,                 _shrink_factor,         size_t)                        \
+  nonstatic_field(TenuredGeneration,                 _capacity_at_prologue,  size_t)                        \
+  nonstatic_field(TenuredGeneration,                 _used_at_prologue,      size_t)                        \
+  nonstatic_field(TenuredGeneration,                 _min_heap_delta_bytes,  size_t)                        \
+  nonstatic_field(TenuredGeneration,                 _the_space,             TenuredSpace*)                 \
+                                                                                                            \
+  nonstatic_field(DefNewGeneration,                  _old_gen,               Generation*)                   \
+  nonstatic_field(DefNewGeneration,                  _tenuring_threshold,    uint)                          \
+  nonstatic_field(DefNewGeneration,                  _age_table,             AgeTable)                      \
+  nonstatic_field(DefNewGeneration,                  _eden_space,            ContiguousSpace*)              \
+  nonstatic_field(DefNewGeneration,                  _from_space,            ContiguousSpace*)              \
+  nonstatic_field(DefNewGeneration,                  _to_space,              ContiguousSpace*)              \
+                                                                                                            \
+  nonstatic_field(SerialBlockOffsetTable,            _array,                 SerialBlockOffsetSharedArray*) \
+                                                                                                            \
+  nonstatic_field(SerialBlockOffsetSharedArray,      _reserved,              MemRegion)                     \
+  nonstatic_field(SerialBlockOffsetSharedArray,      _vs,                    VirtualSpace)                  \
+  nonstatic_field(SerialBlockOffsetSharedArray,      _offset_array,          u_char*)                       \
+                                                                                                            \
+  nonstatic_field(TenuredSpace,                      _offsets,               SerialBlockOffsetTable)
 
 #define VM_TYPES_SERIALGC(declare_type,                                       \
                           declare_toplevel_type,                              \
@@ -73,11 +66,8 @@
   declare_type(CardTableRS, CardTable)                                        \
                                                                               \
   declare_toplevel_type(TenuredGeneration*)                                   \
-  declare_toplevel_type(BlockOffsetSharedArray)                               \
-  declare_toplevel_type(BlockOffsetTable)                                     \
-           declare_type(BlockOffsetArray,             BlockOffsetTable)       \
-           declare_type(BlockOffsetArrayContigSpace,  BlockOffsetArray)       \
-  declare_toplevel_type(BlockOffsetSharedArray*)
+  declare_toplevel_type(SerialBlockOffsetSharedArray)                         \
+  declare_toplevel_type(SerialBlockOffsetTable)
 
 #define VM_INT_CONSTANTS_SERIALGC(declare_constant,                           \
                                   declare_constant_with_value)

src/hotspot/share/gc/serial/tenuredGeneration.hpp

@@ -87,25 +87,6 @@ bool ContiguousSpace::is_free_block(const HeapWord* p) const {
   return p >= _top;
 }
 
-#if INCLUDE_SERIALGC
-void TenuredSpace::clear(bool mangle_space) {
-  ContiguousSpace::clear(mangle_space);
-  _offsets.initialize_threshold();
-}
-
-void TenuredSpace::set_bottom(HeapWord* new_bottom) {
-  Space::set_bottom(new_bottom);
-  _offsets.set_bottom(new_bottom);
-}
-
-void TenuredSpace::set_end(HeapWord* new_end) {
-  // Space should not advertise an increase in size
-  // until after the underlying offset table has been enlarged.
-  _offsets.resize(pointer_delta(new_end, bottom()));
-  Space::set_end(new_end);
-}
-#endif // INCLUDE_SERIALGC
-
 #ifndef PRODUCT
 
 void ContiguousSpace::set_top_for_allocations(HeapWord* v) {
@@ -152,7 +133,6 @@ HeapWord* ContiguousSpace::forward(oop q, size_t size,
     }
     compact_top = cp->space->bottom();
     cp->space->set_compaction_top(compact_top);
-    cp->space->initialize_threshold();
     compaction_max_size = pointer_delta(cp->space->end(), compact_top);
   }
 
@@ -172,7 +152,7 @@ HeapWord* ContiguousSpace::forward(oop q, size_t size,
   // We need to update the offset table so that the beginnings of objects can be
   // found during scavenge.  Note that we are updating the offset table based on
   // where the object will be once the compaction phase finishes.
-  cp->space->alloc_block(compact_top - size, compact_top);
+  cp->space->update_for_block(compact_top - size, compact_top);
   return compact_top;
 }
 
@@ -190,7 +170,6 @@ void ContiguousSpace::prepare_for_compaction(CompactPoint* cp) {
     assert(cp->gen != nullptr, "need a generation");
     assert(cp->gen->first_compaction_space() == this, "just checking");
     cp->space = cp->gen->first_compaction_space();
-    cp->space->initialize_threshold();
     cp->space->set_compaction_top(cp->space->bottom());
   }
 
@@ -384,9 +363,8 @@ void ContiguousSpace::print_on(outputStream* st) const {
 #if INCLUDE_SERIALGC
 void TenuredSpace::print_on(outputStream* st) const {
   print_short_on(st);
-  st->print_cr(" [" PTR_FORMAT ", " PTR_FORMAT ", "
-                PTR_FORMAT ", " PTR_FORMAT ")",
-              p2i(bottom()), p2i(top()), p2i(_offsets.threshold()), p2i(end()));
+  st->print_cr(" [" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT ")",
+              p2i(bottom()), p2i(top()), p2i(end()));
 }
 #endif
 
@@ -510,20 +488,30 @@ HeapWord* ContiguousSpace::par_allocate(size_t size) {
 }
 
 #if INCLUDE_SERIALGC
-void TenuredSpace::initialize_threshold() {
-  _offsets.initialize_threshold();
+void TenuredSpace::update_for_block(HeapWord* start, HeapWord* end) {
+  _offsets.update_for_block(start, end);
 }
 
-void TenuredSpace::alloc_block(HeapWord* start, HeapWord* end) {
-  _offsets.alloc_block(start, end);
+HeapWord* TenuredSpace::block_start_const(const void* addr) const {
+  HeapWord* cur_block = _offsets.block_start_reaching_into_card(addr);
+
+  while (true) {
+    HeapWord* next_block = cur_block + cast_to_oop(cur_block)->size();
+    if (next_block > addr) {
+      assert(cur_block <= addr, "postcondition");
+      return cur_block;
+    }
+    cur_block = next_block;
+    // Because the BOT is precise, we should never step into the next card
+    // (i.e. crossing the card boundary).
+    assert(!SerialBlockOffsetTable::is_crossing_card_boundary(cur_block, (HeapWord*)addr), "must be");
+  }
 }
 
-TenuredSpace::TenuredSpace(BlockOffsetSharedArray* sharedOffsetArray,
+TenuredSpace::TenuredSpace(SerialBlockOffsetSharedArray* sharedOffsetArray,
                            MemRegion mr) :
-  _offsets(sharedOffsetArray, mr),
-  _par_alloc_lock(Mutex::safepoint, "TenuredSpaceParAlloc_lock", true)
+  _offsets(sharedOffsetArray)
 {
-  _offsets.set_contig_space(this);
   initialize(mr, SpaceDecorator::Clear, SpaceDecorator::Mangle);
 }
 
@@ -536,10 +524,6 @@ void TenuredSpace::verify() const {
   int objs = 0;
   int blocks = 0;
 
-  if (VerifyObjectStartArray) {
-    _offsets.verify();
-  }
-
   while (p < top()) {
     size_t size = cast_to_oop(p)->size();
     // For a sampling of objects in the space, find it using the

src/hotspot/share/gc/serial/vmStructs_serial.hpp

@@ -47,11 +47,6 @@
 // Forward decls.
 class Space;
 class ContiguousSpace;
-#if INCLUDE_SERIALGC
-class BlockOffsetArray;
-class BlockOffsetArrayContigSpace;
-class BlockOffsetTable;
-#endif
 class Generation;
 class ContiguousSpace;
 class CardTableRS;
@@ -241,7 +236,7 @@ class ContiguousSpace: public Space {
 
   // This the function to invoke when an allocation of an object covering
   // "start" to "end" occurs to update other internal data structures.
-  virtual void alloc_block(HeapWord* start, HeapWord* the_end) { }
+  virtual void update_for_block(HeapWord* start, HeapWord* the_end) { }
 
   GenSpaceMangler* mangler() { return _mangler; }
 
@@ -308,11 +303,6 @@ class ContiguousSpace: public Space {
   // live part of a compacted space ("deadwood" support.)
   virtual size_t allowed_dead_ratio() const { return 0; };
 
-  // Some contiguous spaces may maintain some data structures that should
-  // be updated whenever an allocation crosses a boundary.  This function
-  // initializes these data structures for further updates.
-  virtual void initialize_threshold() { }
-
   // "q" is an object of the given "size" that should be forwarded;
   // "cp" names the generation ("gen") and containing "this" (which must
   // also equal "cp->space").  "compact_top" is where in "this" the
@@ -322,7 +312,7 @@ class ContiguousSpace: public Space {
   // be one, since compaction must succeed -- we go to the first space of
   // the previous generation if necessary, updating "cp"), reset compact_top
   // and then forward.  In either case, returns the new value of "compact_top".
-  // Invokes the "alloc_block" function of the then-current compaction
+  // Invokes the "update_for_block" function of the then-current compaction
   // space.
   virtual HeapWord* forward(oop q, size_t size, CompactPoint* cp,
                     HeapWord* compact_top);
@@ -412,36 +402,28 @@ class ContiguousSpace: public Space {
 #if INCLUDE_SERIALGC
 
 // Class TenuredSpace is used by TenuredGeneration; it supports an efficient
-// "block_start" operation via a BlockOffsetArray (whose BlockOffsetSharedArray
-// may be shared with other spaces.)
+// "block_start" operation via a SerialBlockOffsetTable.
 
 class TenuredSpace: public ContiguousSpace {
   friend class VMStructs;
  protected:
-  BlockOffsetArrayContigSpace _offsets;
-  Mutex _par_alloc_lock;
+  SerialBlockOffsetTable _offsets;
 
   // Mark sweep support
   size_t allowed_dead_ratio() const override;
  public:
   // Constructor
-  TenuredSpace(BlockOffsetSharedArray* sharedOffsetArray,
+  TenuredSpace(SerialBlockOffsetSharedArray* sharedOffsetArray,
                MemRegion mr);
 
-  void set_bottom(HeapWord* value) override;
-  void set_end(HeapWord* value) override;
-
-  void clear(bool mangle_space) override;
-
-  inline HeapWord* block_start_const(const void* p) const override;
+  HeapWord* block_start_const(const void* addr) const override;
 
   // Add offset table update.
   inline HeapWord* allocate(size_t word_size) override;
   inline HeapWord* par_allocate(size_t word_size) override;
 
   // MarkSweep support phase3
-  void initialize_threshold() override;
-  void alloc_block(HeapWord* start, HeapWord* end) override;
+  void update_for_block(HeapWord* start, HeapWord* end) override;
 
   void print_on(outputStream* st) const override;
 

src/hotspot/share/gc/shared/space.cpp

@@ -47,36 +47,19 @@ inline HeapWord* Space::block_start(const void* p) {
 inline HeapWord* TenuredSpace::allocate(size_t size) {
   HeapWord* res = ContiguousSpace::allocate(size);
   if (res != nullptr) {
-    _offsets.alloc_block(res, size);
+    _offsets.update_for_block(res, res + size);
   }
   return res;
 }
 
-// Because of the requirement of keeping "_offsets" up to date with the
-// allocations, we sequentialize these with a lock.  Therefore, best if
-// this is used for larger LAB allocations only.
 inline HeapWord* TenuredSpace::par_allocate(size_t size) {
-  MutexLocker x(&_par_alloc_lock);
-  // This ought to be just "allocate", because of the lock above, but that
-  // ContiguousSpace::allocate asserts that either the allocating thread
-  // holds the heap lock or it is the VM thread and we're at a safepoint.
-  // The best I (dld) could figure was to put a field in ContiguousSpace
-  // meaning "locking at safepoint taken care of", and set/reset that
-  // here.  But this will do for now, especially in light of the comment
-  // above.  Perhaps in the future some lock-free manner of keeping the
-  // coordination.
   HeapWord* res = ContiguousSpace::par_allocate(size);
   if (res != nullptr) {
-    _offsets.alloc_block(res, size);
+    _offsets.update_for_block(res, res + size);
   }
   return res;
 }
 
-inline HeapWord*
-TenuredSpace::block_start_const(const void* p) const {
-  return _offsets.block_start(p);
-}
-
 class DeadSpacer : StackObj {
   size_t _allowed_deadspace_words;
   bool _active;