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

@@ -24,20 +24,62 @@
 
 #include "precompiled.hpp"
 #include "gc/parallel/parallelArguments.hpp"
 #include "gc/parallel/parallelScavengeHeap.hpp"
 #include "gc/shared/adaptiveSizePolicy.hpp"
-#include "gc/shared/collectorPolicy.hpp"
 #include "gc/shared/gcArguments.inline.hpp"
+#include "gc/shared/genArguments.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/globals_extension.hpp"
 #include "runtime/java.hpp"
+#include "runtime/os.hpp"
 #include "runtime/vm_version.hpp"
 #include "utilities/defaultStream.hpp"
 
 size_t ParallelArguments::conservative_max_heap_alignment() {
-  return CollectorPolicy::compute_heap_alignment();
+  return compute_heap_alignment();
+}
+
+void ParallelArguments::initialize_heap_flags_one_pass(PSSettings& s) {
+  // Do basic sizing work
+  GenArguments::initialize_heap_flags(s);
+
+  // The survivor ratio's are calculated "raw", unlike the
+  // default gc, which adds 2 to the ratio value. We need to
+  // make sure the values are valid before using them.
+  if (MinSurvivorRatio < 3) {
+    FLAG_SET_ERGO(uintx, MinSurvivorRatio, 3);
+  }
+
+  if (InitialSurvivorRatio < 3) {
+    FLAG_SET_ERGO(uintx, InitialSurvivorRatio, 3);
+  }
+}
+
+PSSettings ParallelArguments::initialize_heap_flags() {
+  PSSettings s;
+
+  initialize_heap_flags_one_pass(s);
+
+  const size_t max_page_sz = os::page_size_for_region_aligned(s._max_heap_byte_size, 8);
+  const size_t min_pages = 4; // 1 for eden + 1 for each survivor + 1 for old
+  const size_t min_page_sz = os::page_size_for_region_aligned(s._min_heap_byte_size, min_pages);
+  const size_t page_sz = MIN2(max_page_sz, min_page_sz);
+
+  // Can a page size be something else than a power of two?
+  assert(is_power_of_2((intptr_t)page_sz), "must be a power of 2");
+  size_t new_alignment = align_up(page_sz, s._gen_alignment);
+  if (new_alignment != s._gen_alignment) {
+    s._gen_alignment = new_alignment;
+    s._space_alignment = new_alignment;
+    // Redo everything from the start
+    initialize_heap_flags_one_pass(s);
+  }
+
+  GenArguments::initialize_size_info(s);
+
+  return s;
 }
 
 void ParallelArguments::initialize_flags() {
   GCArguments::initialize_flags();
   assert(UseParallelGC || UseParallelOldGC, "Error");

@@ -90,7 +132,7 @@
     }
   }
 }
 
 CollectedHeap* ParallelArguments::create_heap() {
-  return create_heap_with_policy<ParallelScavengeHeap, GenerationSizer>();
+  return new ParallelScavengeHeap(initialize_heap_flags());
 }