8295658: G1: Refactor G1SegmentedArray to indicate that it is an allocator

Reviewed-by: tschatzl, sjohanss

Author: Ivan Walulya

src/hotspot/share/gc/g1/g1CardSetMemory.cpp

@@ -26,17 +26,17 @@
 
 #include "gc/g1/g1CardSetContainers.inline.hpp"
 #include "gc/g1/g1CardSetMemory.inline.hpp"
-#include "gc/g1/g1SegmentedArray.inline.hpp"
+#include "gc/g1/g1MonotonicArena.inline.hpp"
 #include "runtime/atomic.hpp"
 #include "utilities/ostream.hpp"
 
 G1CardSetAllocator::G1CardSetAllocator(const char* name,
                                        const G1CardSetAllocOptions* alloc_options,
-                                       G1CardSetFreeList* free_segment_list) :
-  _segmented_array(alloc_options, free_segment_list),
-  _free_slots_list(name, &_segmented_array)
+                                       SegmentFreeList* segment_free_list) :
+  _arena(alloc_options, segment_free_list),
+  _free_slots_list(name, &_arena)
 {
-  uint slot_size = _segmented_array.slot_size();
+  uint slot_size = _arena.slot_size();
   assert(slot_size >= sizeof(G1CardSetContainer), "Slot instance size %u for allocator %s too small", slot_size, name);
 }
 
@@ -51,23 +51,23 @@ void G1CardSetAllocator::free(void* slot) {
 
 void G1CardSetAllocator::drop_all() {
   _free_slots_list.reset();
-  _segmented_array.drop_all();
+  _arena.drop_all();
 }
 
 size_t G1CardSetAllocator::mem_size() const {
   return sizeof(*this) +
-         num_segments() * sizeof(G1CardSetSegment) +
-         _segmented_array.num_total_slots() * _segmented_array.slot_size();
+         num_segments() * sizeof(Segment) +
+         _arena.num_total_slots() * _arena.slot_size();
 }
 
 size_t G1CardSetAllocator::unused_mem_size() const {
-  uint num_unused_slots = (_segmented_array.num_total_slots() - _segmented_array.num_allocated_slots()) +
+  uint num_unused_slots = (_arena.num_total_slots() - _arena.num_allocated_slots()) +
                           (uint)_free_slots_list.free_count();
-  return num_unused_slots * _segmented_array.slot_size();
+  return num_unused_slots * _arena.slot_size();
 }
 
 uint G1CardSetAllocator::num_segments() const {
-  return _segmented_array.num_segments();
+  return _arena.num_segments();
 }
 
 G1CardSetMemoryManager::G1CardSetMemoryManager(G1CardSetConfiguration* config,
@@ -123,8 +123,8 @@ size_t G1CardSetMemoryManager::unused_mem_size() const {
   return result;
 }
 
-G1SegmentedArrayMemoryStats G1CardSetMemoryManager::memory_stats() const {
-  G1SegmentedArrayMemoryStats result;
+G1MonotonicArenaMemoryStats G1CardSetMemoryManager::memory_stats() const {
+  G1MonotonicArenaMemoryStats result;
   for (uint i = 0; i < num_mem_object_types(); i++) {
     result._num_mem_sizes[i] += _allocators[i].mem_size();
     result._num_segments[i] += _allocators[i].num_segments();

src/hotspot/share/gc/g1/g1CardSetMemory.hpp

@@ -27,8 +27,8 @@
 
 #include "gc/g1/g1CardSet.hpp"
 #include "gc/g1/g1CardSetContainers.hpp"
-#include "gc/g1/g1SegmentedArray.hpp"
-#include "gc/g1/g1SegmentedArrayFreePool.hpp"
+#include "gc/g1/g1MonotonicArena.hpp"
+#include "gc/g1/g1MonotonicArenaFreePool.hpp"
 #include "gc/shared/freeListAllocator.hpp"
 #include "memory/allocation.hpp"
 #include "utilities/growableArray.hpp"
@@ -37,8 +37,8 @@ class G1CardSetConfiguration;
 class outputStream;
 
 // Collects G1CardSetAllocator options/heuristics. Called by G1CardSetAllocator
-// to determine the next size of the allocated G1CardSetSegment.
-class G1CardSetAllocOptions : public G1SegmentedArrayAllocOptions {
+// to determine the next size of the allocated memory Segment.
+class G1CardSetAllocOptions : public G1MonotonicArena::AllocOptions {
   static const uint MinimumNumSlots = 8;
   static const uint MaximumNumSlots = UINT_MAX / 2;
 
@@ -50,30 +50,28 @@ class G1CardSetAllocOptions : public G1SegmentedArrayAllocOptions {
   static const uint SlotAlignment = 8;
 
   G1CardSetAllocOptions(uint slot_size, uint initial_num_slots = MinimumNumSlots, uint max_num_slots = MaximumNumSlots) :
-    G1SegmentedArrayAllocOptions(mtGCCardSet, slot_size, initial_num_slots, max_num_slots, SlotAlignment) {
+    G1MonotonicArena::AllocOptions(mtGCCardSet, slot_size, initial_num_slots, max_num_slots, SlotAlignment) {
   }
 
   virtual uint next_num_slots(uint prev_num_slots) const override {
     return exponential_expand(prev_num_slots);
   }
 };
 
-using G1CardSetSegment = G1SegmentedArraySegment;
-
-using G1CardSetFreeList = G1SegmentedArrayFreeList;
-
 // Arena-like allocator for (card set) heap memory objects.
 //
 // Allocation occurs from an internal free list of objects first. If the free list is
-// empty then tries to allocate from the G1SegmentedArray.
+// empty then tries to allocate from the G1MonotonicArena.
 class G1CardSetAllocator {
-  G1SegmentedArray _segmented_array;
+  using Segment = G1MonotonicArena::Segment;
+  using SegmentFreeList = G1MonotonicArena::SegmentFreeList;
+  G1MonotonicArena _arena;
   FreeListAllocator _free_slots_list;
 
 public:
   G1CardSetAllocator(const char* name,
                      const G1CardSetAllocOptions* alloc_options,
-                     G1CardSetFreeList* free_segment_list);
+                     SegmentFreeList* segment_free_list);
   ~G1CardSetAllocator();
 
   void* allocate();
@@ -91,7 +89,7 @@ class G1CardSetAllocator {
   uint num_segments() const;
 };
 
-using G1CardSetFreePool = G1SegmentedArrayFreePool;
+using G1CardSetFreePool = G1MonotonicArenaFreePool;
 
 class G1CardSetMemoryManager : public CHeapObj<mtGCCardSet> {
   G1CardSetConfiguration* _config;
@@ -118,7 +116,7 @@ class G1CardSetMemoryManager : public CHeapObj<mtGCCardSet> {
   size_t mem_size() const;
   size_t unused_mem_size() const;
 
-  G1SegmentedArrayMemoryStats memory_stats() const;
+  G1MonotonicArenaMemoryStats memory_stats() const;
 };
 
 #endif // SHARE_GC_G1_G1CARDSETMEMORY_HPP

src/hotspot/share/gc/g1/g1CardSetMemory.inline.hpp

@@ -27,7 +27,7 @@
 
 #include "gc/g1/g1CardSetMemory.hpp"
 #include "gc/g1/g1CardSetContainers.inline.hpp"
-#include "gc/g1/g1SegmentedArray.inline.hpp"
+#include "gc/g1/g1MonotonicArena.inline.hpp"
 #include "utilities/globalCounter.inline.hpp"
 #include "utilities/ostream.hpp"
 

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -53,6 +53,7 @@
 #include "gc/g1/g1HotCardCache.hpp"
 #include "gc/g1/g1InitLogger.hpp"
 #include "gc/g1/g1MemoryPool.hpp"
+#include "gc/g1/g1MonotonicArenaFreeMemoryTask.hpp"
 #include "gc/g1/g1OopClosures.inline.hpp"
 #include "gc/g1/g1ParallelCleaning.hpp"
 #include "gc/g1/g1ParScanThreadState.inline.hpp"
@@ -64,7 +65,6 @@
 #include "gc/g1/g1RootClosures.hpp"
 #include "gc/g1/g1RootProcessor.hpp"
 #include "gc/g1/g1SATBMarkQueueSet.hpp"
-#include "gc/g1/g1SegmentedArrayFreeMemoryTask.hpp"
 #include "gc/g1/g1ServiceThread.hpp"
 #include "gc/g1/g1ThreadLocalData.hpp"
 #include "gc/g1/g1Trace.hpp"
@@ -1429,7 +1429,7 @@ G1CollectedHeap::G1CollectedHeap() :
   CollectedHeap(),
   _service_thread(NULL),
   _periodic_gc_task(NULL),
-  _free_segmented_array_memory_task(NULL),
+  _free_arena_memory_task(NULL),
   _workers(NULL),
   _card_table(NULL),
   _collection_pause_end(Ticks::now()),
@@ -1717,8 +1717,8 @@ jint G1CollectedHeap::initialize() {
   _periodic_gc_task = new G1PeriodicGCTask("Periodic GC Task");
   _service_thread->register_task(_periodic_gc_task);
 
-  _free_segmented_array_memory_task = new G1SegmentedArrayFreeMemoryTask("Card Set Free Memory Task");
-  _service_thread->register_task(_free_segmented_array_memory_task);
+  _free_arena_memory_task = new G1MonotonicArenaFreeMemoryTask("Card Set Free Memory Task");
+  _service_thread->register_task(_free_arena_memory_task);
 
   // Here we allocate the dummy HeapRegion that is required by the
   // G1AllocRegion class.
@@ -2612,8 +2612,8 @@ void G1CollectedHeap::gc_epilogue(bool full) {
 
   _collection_pause_end = Ticks::now();
 
-  _free_segmented_array_memory_task->notify_new_stats(&_young_gen_card_set_stats,
-                                                      &_collection_set_candidates_card_set_stats);
+  _free_arena_memory_task->notify_new_stats(&_young_gen_card_set_stats,
+                                            &_collection_set_candidates_card_set_stats);
 }
 
 uint G1CollectedHeap::uncommit_regions(uint region_limit) {
@@ -2922,11 +2922,11 @@ bool G1CollectedHeap::should_sample_collection_set_candidates() const {
   return candidates != NULL && candidates->num_remaining() > 0;
 }
 
-void G1CollectedHeap::set_collection_set_candidates_stats(G1SegmentedArrayMemoryStats& stats) {
+void G1CollectedHeap::set_collection_set_candidates_stats(G1MonotonicArenaMemoryStats& stats) {
   _collection_set_candidates_card_set_stats = stats;
 }
 
-void G1CollectedHeap::set_young_gen_card_set_stats(const G1SegmentedArrayMemoryStats& stats) {
+void G1CollectedHeap::set_young_gen_card_set_stats(const G1MonotonicArenaMemoryStats& stats) {
   _young_gen_card_set_stats = stats;
 }
 

src/hotspot/share/gc/g1/g1CollectedHeap.hpp

@@ -40,8 +40,8 @@
 #include "gc/g1/g1HeapVerifier.hpp"
 #include "gc/g1/g1HRPrinter.hpp"
 #include "gc/g1/g1MonitoringSupport.hpp"
+#include "gc/g1/g1MonotonicArenaFreeMemoryTask.hpp"
 #include "gc/g1/g1NUMA.hpp"
-#include "gc/g1/g1SegmentedArrayFreeMemoryTask.hpp"
 #include "gc/g1/g1SurvivorRegions.hpp"
 #include "gc/g1/g1YoungGCEvacFailureInjector.hpp"
 #include "gc/g1/heapRegionManager.hpp"
@@ -145,7 +145,7 @@ class G1CollectedHeap : public CollectedHeap {
 private:
   G1ServiceThread* _service_thread;
   G1ServiceTask* _periodic_gc_task;
-  G1SegmentedArrayFreeMemoryTask* _free_segmented_array_memory_task;
+  G1MonotonicArenaFreeMemoryTask* _free_arena_memory_task;
 
   WorkerThreads* _workers;
   G1CardTable* _card_table;
@@ -162,9 +162,9 @@ class G1CollectedHeap : public CollectedHeap {
   HeapRegionSet _humongous_set;
 
   // Young gen memory statistics before GC.
-  G1SegmentedArrayMemoryStats _young_gen_card_set_stats;
+  G1MonotonicArenaMemoryStats _young_gen_card_set_stats;
   // Collection set candidates memory statistics after GC.
-  G1SegmentedArrayMemoryStats _collection_set_candidates_card_set_stats;
+  G1MonotonicArenaMemoryStats _collection_set_candidates_card_set_stats;
 
   // The block offset table for the G1 heap.
   G1BlockOffsetTable* _bot;
@@ -239,8 +239,8 @@ class G1CollectedHeap : public CollectedHeap {
   void set_humongous_stats(uint num_humongous_total, uint num_humongous_candidates);
 
   bool should_sample_collection_set_candidates() const;
-  void set_collection_set_candidates_stats(G1SegmentedArrayMemoryStats& stats);
-  void set_young_gen_card_set_stats(const G1SegmentedArrayMemoryStats& stats);
+  void set_collection_set_candidates_stats(G1MonotonicArenaMemoryStats& stats);
+  void set_young_gen_card_set_stats(const G1MonotonicArenaMemoryStats& stats);
 
 private: