8319703: Serial: Remove generationSpec

Reviewed-by: cjplummer, tschatzl

Author: albertnetymk

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

@@ -81,7 +81,6 @@
 #include "gc/shared/gcLocker.inline.hpp"
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
-#include "gc/shared/generationSpec.hpp"
 #include "gc/shared/isGCActiveMark.hpp"
 #include "gc/shared/locationPrinter.inline.hpp"
 #include "gc/shared/oopStorageParState.hpp"

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

@@ -40,7 +40,6 @@
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
-#include "gc/shared/generationSpec.hpp"
 #include "gc/shared/preservedMarks.inline.hpp"
 #include "gc/shared/referencePolicy.hpp"
 #include "gc/shared/referenceProcessorPhaseTimes.hpp"
@@ -560,7 +559,7 @@ void DefNewGeneration::compute_new_size() {
 
   size_t old_size = gch->old_gen()->capacity();
   size_t new_size_before = _virtual_space.committed_size();
-  size_t min_new_size = initial_size();
+  size_t min_new_size = NewSize;
   size_t max_new_size = reserved().byte_size();
   assert(min_new_size <= new_size_before &&
          new_size_before <= max_new_size,

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

@@ -31,7 +31,6 @@
 #include "gc/shared/gcLocker.hpp"
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
-#include "gc/shared/generationSpec.hpp"
 #include "gc/shared/space.inline.hpp"
 #include "gc/shared/spaceDecorator.inline.hpp"
 #include "logging/log.hpp"
@@ -57,14 +56,6 @@ Generation::Generation(ReservedSpace rs, size_t initial_size) :
           (HeapWord*)_virtual_space.high_boundary());
 }
 
-size_t Generation::initial_size() {
-  SerialHeap* serial_heap = SerialHeap::heap();
-  if (serial_heap->is_young_gen(this)) {
-    return serial_heap->young_gen_spec()->init_size();
-  }
-  return serial_heap->old_gen_spec()->init_size();
-}
-
 size_t Generation::max_capacity() const {
   return reserved().byte_size();
 }

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

@@ -50,7 +50,6 @@
 
 class DefNewGeneration;
 class GCMemoryManager;
-class GenerationSpec;
 class ContiguousSpace;
 class CompactPoint;
 class OopClosure;
@@ -113,8 +112,6 @@ class Generation: public CHeapObj<mtGC> {
 
   virtual Generation::Name kind() { return Generation::Other; }
 
-  // Space inquiries (results in bytes)
-  size_t initial_size();
   virtual size_t capacity() const = 0;  // The maximum number of object bytes the
                                         // generation can currently hold.
   virtual size_t used() const = 0;      // The number of used bytes in the gen.

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

@@ -32,7 +32,6 @@
 #include "gc/shared/gcLocker.hpp"
 #include "gc/shared/gcTimer.hpp"
 #include "gc/shared/gcTrace.hpp"
-#include "gc/shared/generationSpec.hpp"
 #include "gc/shared/space.hpp"
 #include "logging/log.hpp"
 #include "memory/allocation.inline.hpp"
@@ -165,7 +164,7 @@ void TenuredGeneration::compute_new_size_inner() {
   const double min_tmp = used_after_gc / maximum_used_percentage;
   size_t minimum_desired_capacity = (size_t)MIN2(min_tmp, double(max_uintx));
   // Don't shrink less than the initial generation size
-  minimum_desired_capacity = MAX2(minimum_desired_capacity, initial_size());
+  minimum_desired_capacity = MAX2(minimum_desired_capacity, OldSize);
   assert(used_after_gc <= minimum_desired_capacity, "sanity check");
 
     const size_t free_after_gc = free();
@@ -204,7 +203,7 @@ void TenuredGeneration::compute_new_size_inner() {
     const double minimum_used_percentage = 1.0 - maximum_free_percentage;
     const double max_tmp = used_after_gc / minimum_used_percentage;
     size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx));
-    maximum_desired_capacity = MAX2(maximum_desired_capacity, initial_size());
+    maximum_desired_capacity = MAX2(maximum_desired_capacity, OldSize);
     log_trace(gc, heap)("    maximum_free_percentage: %6.2f  minimum_used_percentage: %6.2f",
                              maximum_free_percentage, minimum_used_percentage);
     log_trace(gc, heap)("    _capacity_at_prologue: %6.1fK  minimum_desired_capacity: %6.1fK  maximum_desired_capacity: %6.1fK",
@@ -234,7 +233,7 @@ void TenuredGeneration::compute_new_size_inner() {
       }
       assert(shrink_bytes <= max_shrink_bytes, "invalid shrink size");
       log_trace(gc, heap)("    shrinking:  initSize: %.1fK  maximum_desired_capacity: %.1fK",
-                               initial_size() / (double) K, maximum_desired_capacity / (double) K);
+                               OldSize / (double) K, maximum_desired_capacity / (double) K);
       log_trace(gc, heap)("    shrink_bytes: %.1fK  current_shrink_factor: " SIZE_FORMAT "  new shrink factor: " SIZE_FORMAT "  _min_heap_delta_bytes: %.1fK",
                                shrink_bytes / (double) K,
                                current_shrink_factor,

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

@@ -34,6 +34,7 @@
 #include "gc/serial/defNewGeneration.hpp"
 #include "gc/serial/genMarkSweep.hpp"
 #include "gc/serial/markSweep.hpp"
+#include "gc/serial/tenuredGeneration.hpp"
 #include "gc/shared/cardTableBarrierSet.hpp"
 #include "gc/shared/collectedHeap.inline.hpp"
 #include "gc/shared/collectorCounters.hpp"
@@ -47,7 +48,6 @@
 #include "gc/shared/gcVMOperations.hpp"
 #include "gc/shared/genArguments.hpp"
 #include "gc/shared/genCollectedHeap.hpp"
-#include "gc/shared/generationSpec.hpp"
 #include "gc/shared/locationPrinter.inline.hpp"
 #include "gc/shared/oopStorage.inline.hpp"
 #include "gc/shared/oopStorageParState.inline.hpp"
@@ -85,14 +85,6 @@ GenCollectedHeap::GenCollectedHeap(Generation::Name young,
   CollectedHeap(),
   _young_gen(nullptr),
   _old_gen(nullptr),
-  _young_gen_spec(new GenerationSpec(young,
-                                     NewSize,
-                                     MaxNewSize,
-                                     GenAlignment)),
-  _old_gen_spec(new GenerationSpec(old,
-                                   OldSize,
-                                   MaxOldSize,
-                                   GenAlignment)),
   _rem_set(nullptr),
   _soft_ref_policy(),
   _gc_policy_counters(new GCPolicyCounters(policy_counters_name, 2, 2)),
@@ -115,8 +107,8 @@ jint GenCollectedHeap::initialize() {
 
   initialize_reserved_region(heap_rs);
 
-  ReservedSpace young_rs = heap_rs.first_part(_young_gen_spec->max_size());
-  ReservedSpace old_rs = heap_rs.last_part(_young_gen_spec->max_size());
+  ReservedSpace young_rs = heap_rs.first_part(MaxNewSize);
+  ReservedSpace old_rs = heap_rs.last_part(MaxNewSize);
 
   _rem_set = create_rem_set(heap_rs.region());
   _rem_set->initialize(young_rs.base(), old_rs.base());
@@ -125,8 +117,8 @@ jint GenCollectedHeap::initialize() {
   bs->initialize();
   BarrierSet::set_barrier_set(bs);
 
-  _young_gen = _young_gen_spec->init(young_rs, rem_set());
-  _old_gen = _old_gen_spec->init(old_rs, rem_set());
+  _young_gen = new DefNewGeneration(young_rs, NewSize, MinNewSize, MaxNewSize);
+  _old_gen = new TenuredGeneration(old_rs, OldSize, MinOldSize, MaxOldSize, rem_set());
 
   GCInitLogger::print();
 
@@ -143,8 +135,8 @@ ReservedHeapSpace GenCollectedHeap::allocate(size_t alignment) {
   assert(alignment % pageSize == 0, "Must be");
 
   // Check for overflow.
-  size_t total_reserved = _young_gen_spec->max_size() + _old_gen_spec->max_size();
-  if (total_reserved < _young_gen_spec->max_size()) {
+  size_t total_reserved = MaxNewSize + MaxOldSize;
+  if (total_reserved < MaxNewSize) {
     vm_exit_during_initialization("The size of the object heap + VM data exceeds "
                                   "the maximum representable size");
   }
@@ -199,14 +191,6 @@ PreGenGCValues GenCollectedHeap::get_pre_gc_values() const {
                         old_gen()->capacity());
 }
 
-GenerationSpec* GenCollectedHeap::young_gen_spec() const {
-  return _young_gen_spec;
-}
-
-GenerationSpec* GenCollectedHeap::old_gen_spec() const {
-  return _old_gen_spec;
-}
-
 size_t GenCollectedHeap::capacity() const {
   return _young_gen->capacity() + _old_gen->capacity();
 }

src/hotspot/share/gc/shared/genCollectedHeap.hpp

@@ -33,7 +33,6 @@
 
 class CardTableRS;
 class GCPolicyCounters;
-class GenerationSpec;
 
 // A "GenCollectedHeap" is a CollectedHeap that uses generational
 // collection.  It has two generations, young and old.
@@ -62,9 +61,6 @@ class GenCollectedHeap : public CollectedHeap {
   Generation* _old_gen;
 
 private:
-  GenerationSpec* _young_gen_spec;
-  GenerationSpec* _old_gen_spec;
-
   // The singleton CardTable Remembered Set.
   CardTableRS* _rem_set;
 
@@ -144,9 +140,6 @@ class GenCollectedHeap : public CollectedHeap {
   MemRegion reserved_region() const { return _reserved; }
   bool is_in_reserved(const void* addr) const { return _reserved.contains(addr); }
 
-  GenerationSpec* young_gen_spec() const;
-  GenerationSpec* old_gen_spec() const;
-
   SoftRefPolicy* soft_ref_policy() override { return &_soft_ref_policy; }
 
   // Performance Counter support

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

@@ -29,7 +29,6 @@
 #include "gc/shared/cardTable.hpp"
 #include "gc/shared/collectedHeap.hpp"
 #include "gc/shared/genCollectedHeap.hpp"
-#include "gc/shared/generationSpec.hpp"
 #include "gc/shared/oopStorage.hpp"
 #include "gc/shared/space.hpp"
 #if INCLUDE_EPSILONGC
@@ -114,14 +113,8 @@
   nonstatic_field(Generation::StatRecord,      invocations,                                   int)                                   \
   nonstatic_field(Generation::StatRecord,      accumulated_time,                              elapsedTimer)                          \
                                                                                                                                      \
-  nonstatic_field(GenerationSpec,              _name,                                         Generation::Name)                      \
-  nonstatic_field(GenerationSpec,              _init_size,                                    size_t)                                \
-  nonstatic_field(GenerationSpec,              _max_size,                                     size_t)                                \
-                                                                                                                                     \
   nonstatic_field(GenCollectedHeap,            _young_gen,                                    Generation*)                           \
   nonstatic_field(GenCollectedHeap,            _old_gen,                                      Generation*)                           \
-  nonstatic_field(GenCollectedHeap,            _young_gen_spec,                               GenerationSpec*)                       \
-  nonstatic_field(GenCollectedHeap,            _old_gen_spec,                                 GenerationSpec*)                       \
                                                                                                                                      \
   nonstatic_field(MemRegion,                   _start,                                        HeapWord*)                             \
   nonstatic_field(MemRegion,                   _word_size,                                    size_t)                                \
@@ -172,7 +165,6 @@
   declare_toplevel_type(AgeTable)                                         \
   declare_toplevel_type(CardTable::CardValue)                             \
   declare_toplevel_type(Generation::StatRecord)                           \
-  declare_toplevel_type(GenerationSpec)                                   \
   declare_toplevel_type(HeapWord)                                         \
   declare_toplevel_type(MemRegion)                                        \
   declare_toplevel_type(ThreadLocalAllocBuffer)                           \
@@ -190,7 +182,6 @@
   declare_toplevel_type(DefNewGeneration*)                                \
   declare_toplevel_type(GenCollectedHeap*)                                \
   declare_toplevel_type(Generation*)                                      \
-  declare_toplevel_type(GenerationSpec**)                                 \
   declare_toplevel_type(HeapWord*)                                        \
   declare_toplevel_type(HeapWord* volatile)                               \
   declare_toplevel_type(MemRegion*)                                       \