Re-order methods for consistency in class hierarchy

Author: jsikstro

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

@@ -37,22 +37,45 @@
 #include "utilities/defaultStream.hpp"
 #include "utilities/powerOfTwo.hpp"
 
-size_t ParallelArguments::conservative_max_heap_alignment() {
-  // The card marking array and the offset arrays for old generations are
-  // committed in os pages as well. Make sure they are entirely full (to
-  // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1
-  // byte entry and the os page size is 4096, the maximum heap size should
-  // be 512*4096 = 2MB aligned.
+static size_t num_young_spaces() {
+  // When using NUMA, we create one MutableNUMASpace for each NUMA node
+  const size_t num_eden_spaces = UseNUMA ? os::numa_get_groups_num() : 1;
 
-  size_t alignment = CardTable::ct_max_alignment_constraint();
+  // The young generation must have room for eden + two survivors
+  return num_eden_spaces + 2;
+}
+
+static size_t num_old_spaces() {
+  return 1;
+}
+
+void ParallelArguments::initialize_alignments() {
+  // Initialize card size before initializing alignments
+  CardTable::initialize_card_size();
+  const size_t card_table_alignment = CardTable::ct_max_alignment_constraint();
+  SpaceAlignment = ParallelScavengeHeap::default_space_alignment();
 
   if (UseLargePages) {
-      // In presence of large pages we have to make sure that our
-      // alignment is large page aware.
-      alignment = lcm(os::large_page_size(), alignment);
-  }
+    const size_t total_spaces = num_young_spaces() + num_old_spaces();
+    const size_t page_size =  os::page_size_for_region_unaligned(MaxHeapSize, total_spaces);
+    ParallelScavengeHeap::set_desired_page_size(page_size);
 
-  return alignment;
+    if (page_size == os::vm_page_size()) {
+      log_warning(gc, heap)("MaxHeapSize (%zu) must be large enough for %zu * page-size; Disabling UseLargePages for heap",
+                            MaxHeapSize, total_spaces);
+    }
+
+    if (page_size > SpaceAlignment) {
+      SpaceAlignment = page_size;
+    }
+
+    HeapAlignment = lcm(page_size, card_table_alignment);
+
+  } else {
+    assert(is_aligned(SpaceAlignment, os::vm_page_size()), "");
+    ParallelScavengeHeap::set_desired_page_size(os::vm_page_size());
+    HeapAlignment = card_table_alignment;
+  }
 }
 
 void ParallelArguments::initialize() {
@@ -112,45 +135,26 @@ void ParallelArguments::initialize() {
   FullGCForwarding::initialize_flags(heap_reserved_size_bytes());
 }
 
-static size_t num_young_spaces() {
-  // When using NUMA, we create one MutableNUMASpace for each NUMA node
-  const size_t num_eden_spaces = UseNUMA ? os::numa_get_groups_num() : 1;
-
-  // The young generation must have room for eden + two survivors
-  return num_eden_spaces + 2;
-}
-
-static size_t num_old_spaces() {
-  return 1;
-}
+size_t ParallelArguments::conservative_max_heap_alignment() {
+  // The card marking array and the offset arrays for old generations are
+  // committed in os pages as well. Make sure they are entirely full (to
+  // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1
+  // byte entry and the os page size is 4096, the maximum heap size should
+  // be 512*4096 = 2MB aligned.
 
-void ParallelArguments::initialize_alignments() {
-  // Initialize card size before initializing alignments
-  CardTable::initialize_card_size();
-  const size_t card_table_alignment = CardTable::ct_max_alignment_constraint();
-  SpaceAlignment = ParallelScavengeHeap::default_space_alignment();
+  size_t alignment = CardTable::ct_max_alignment_constraint();
 
   if (UseLargePages) {
-    const size_t total_spaces = num_young_spaces() + num_old_spaces();
-    const size_t page_size =  os::page_size_for_region_unaligned(MaxHeapSize, total_spaces);
-    ParallelScavengeHeap::set_desired_page_size(page_size);
-
-    if (page_size == os::vm_page_size()) {
-      log_warning(gc, heap)("MaxHeapSize (%zu) must be large enough for %zu * page-size; Disabling UseLargePages for heap",
-                            MaxHeapSize, total_spaces);
-    }
-
-    if (page_size > SpaceAlignment) {
-      SpaceAlignment = page_size;
-    }
+      // In presence of large pages we have to make sure that our
+      // alignment is large page aware.
+      alignment = lcm(os::large_page_size(), alignment);
+  }
 
-    HeapAlignment = lcm(page_size, card_table_alignment);
+  return alignment;
+}
 
-  } else {
-    assert(is_aligned(SpaceAlignment, os::vm_page_size()), "");
-    ParallelScavengeHeap::set_desired_page_size(os::vm_page_size());
-    HeapAlignment = card_table_alignment;
-  }
+CollectedHeap* ParallelArguments::create_heap() {
+  return new ParallelScavengeHeap();
 }
 
 size_t ParallelArguments::young_gen_size_lower_bound() {
@@ -164,7 +168,3 @@ size_t ParallelArguments::old_gen_size_lower_bound() {
 size_t ParallelArguments::heap_reserved_size_bytes() {
   return MaxHeapSize;
 }
-
-CollectedHeap* ParallelArguments::create_heap() {
-  return new ParallelScavengeHeap();
-}

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

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2017, Red Hat, Inc. and/or its affiliates.
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,15 +26,11 @@
 #ifndef SHARE_GC_PARALLEL_PARALLELARGUMENTS_HPP
 #define SHARE_GC_PARALLEL_PARALLELARGUMENTS_HPP
 
-#include "gc/shared/gcArguments.hpp"
 #include "gc/shared/genArguments.hpp"
 
-class CollectedHeap;
-
 class ParallelArguments : public GenArguments {
 private:
   virtual void initialize_alignments();
-
   virtual void initialize();
   virtual size_t conservative_max_heap_alignment();
   virtual CollectedHeap* create_heap();

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

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2017, Red Hat, Inc. and/or its affiliates.
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -45,20 +46,20 @@ static size_t compute_heap_alignment() {
   return alignment;
 }
 
-size_t SerialArguments::conservative_max_heap_alignment() {
-  return MAX2((size_t)Generation::GenGrain, compute_heap_alignment());
+void SerialArguments::initialize_alignments() {
+  // Initialize card size before initializing alignments
+  CardTable::initialize_card_size();
+  SpaceAlignment = (size_t)Generation::GenGrain;
+  HeapAlignment = compute_heap_alignment();
 }
 
 void SerialArguments::initialize() {
   GCArguments::initialize();
   FullGCForwarding::initialize_flags(MaxHeapSize);
 }
 
-void SerialArguments::initialize_alignments() {
-  // Initialize card size before initializing alignments
-  CardTable::initialize_card_size();
-  SpaceAlignment = (size_t)Generation::GenGrain;
-  HeapAlignment = compute_heap_alignment();
+size_t SerialArguments::conservative_max_heap_alignment() {
+  return MAX2((size_t)Generation::GenGrain, compute_heap_alignment());
 }
 
 CollectedHeap* SerialArguments::create_heap() {

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

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2017, Red Hat, Inc. and/or its affiliates.
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -27,13 +28,11 @@
 
 #include "gc/shared/genArguments.hpp"
 
-class CollectedHeap;
-
 class SerialArguments : public GenArguments {
 private:
-  size_t conservative_max_heap_alignment();
-  virtual void initialize();
   virtual void initialize_alignments();
+  virtual void initialize();
+  virtual size_t conservative_max_heap_alignment();
   virtual CollectedHeap* create_heap();
   virtual size_t young_gen_size_lower_bound();
   virtual size_t old_gen_size_lower_bound();

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

@@ -45,10 +45,11 @@ class GenArguments : public GCArguments {
 
   static size_t scale_by_NewRatio_aligned(size_t base_size, size_t alignment);
 
-protected:
-  virtual void initialize_heap_flags_and_sizes();
   virtual size_t young_gen_size_lower_bound() = 0;
   virtual size_t old_gen_size_lower_bound() = 0;
+
+protected:
+  virtual void initialize_heap_flags_and_sizes();
 };
 
 #endif // SHARE_GC_SHARED_GENARGUMENTS_HPP