8234361: ZGC: Move heuristics code in ZWorker to ZHeuristics

Reviewed-by: eosterlund, stefank

Author: pliden

src/hotspot/share/gc/z/zArguments.cpp

@@ -25,7 +25,7 @@
 #include "gc/z/zAddressSpaceLimit.hpp"
 #include "gc/z/zArguments.hpp"
 #include "gc/z/zCollectedHeap.hpp"
-#include "gc/z/zWorkers.hpp"
+#include "gc/z/zHeuristics.hpp"
 #include "gc/shared/gcArguments.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/globals_extension.hpp"
@@ -59,7 +59,7 @@ void ZArguments::initialize() {
 
   // Select number of parallel threads
   if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
-    FLAG_SET_DEFAULT(ParallelGCThreads, ZWorkers::calculate_nparallel());
+    FLAG_SET_DEFAULT(ParallelGCThreads, ZHeuristics::nparallel_workers());
   }
 
   if (ParallelGCThreads == 0) {
@@ -68,7 +68,7 @@ void ZArguments::initialize() {
 
   // Select number of concurrent threads
   if (FLAG_IS_DEFAULT(ConcGCThreads)) {
-    FLAG_SET_DEFAULT(ConcGCThreads, ZWorkers::calculate_nconcurrent());
+    FLAG_SET_DEFAULT(ConcGCThreads, ZHeuristics::nconcurrent_workers());
   }
 
   if (ConcGCThreads == 0) {

src/hotspot/share/gc/z/zHeuristics.cpp

@@ -62,3 +62,39 @@ bool ZHeuristics::use_per_cpu_shared_small_pages() {
   const size_t per_cpu_share = (MaxHeapSize * 0.03125) / ZCPU::count();
   return per_cpu_share >= ZPageSizeSmall;
 }
+
+static uint nworkers_based_on_ncpus(double cpu_share_in_percent) {
+  return ceil(os::initial_active_processor_count() * cpu_share_in_percent / 100.0);
+}
+
+static uint nworkers_based_on_heap_size(double reserve_share_in_percent) {
+  const int nworkers = (MaxHeapSize * (reserve_share_in_percent / 100.0)) / ZPageSizeSmall;
+  return MAX2(nworkers, 1);
+}
+
+static uint nworkers(double cpu_share_in_percent) {
+  // Cap number of workers so that we don't use more than 2% of the max heap
+  // for the small page reserve. This is useful when using small heaps on
+  // large machines.
+  return MIN2(nworkers_based_on_ncpus(cpu_share_in_percent),
+              nworkers_based_on_heap_size(2.0));
+}
+
+uint ZHeuristics::nparallel_workers() {
+  // Use 60% of the CPUs, rounded up. We would like to use as many threads as
+  // possible to increase parallelism. However, using a thread count that is
+  // close to the number of processors tends to lead to over-provisioning and
+  // scheduling latency issues. Using 60% of the active processors appears to
+  // be a fairly good balance.
+  return nworkers(60.0);
+}
+
+uint ZHeuristics::nconcurrent_workers() {
+  // Use 12.5% of the CPUs, rounded up. The number of concurrent threads we
+  // would like to use heavily depends on the type of workload we are running.
+  // Using too many threads will have a negative impact on the application
+  // throughput, while using too few threads will prolong the GC-cycle and
+  // we then risk being out-run by the application. Using 12.5% of the active
+  // processors appears to be a fairly good balance.
+  return nworkers(12.5);
+}

src/hotspot/share/gc/z/zHeuristics.hpp

@@ -31,6 +31,9 @@ class ZHeuristics : public AllStatic {
   static void set_medium_page_size();
 
   static bool use_per_cpu_shared_small_pages();
+
+  static uint nparallel_workers();
+  static uint nconcurrent_workers();
 };
 
 #endif // SHARE_GC_Z_ZHEURISTICS_HPP

src/hotspot/share/gc/z/zWorkers.cpp

@@ -26,46 +26,9 @@
 #include "gc/z/zTask.hpp"
 #include "gc/z/zThread.hpp"
 #include "gc/z/zWorkers.inline.hpp"
-#include "runtime/os.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/safepoint.hpp"
 
-static uint calculate_nworkers_based_on_ncpus(double cpu_share_in_percent) {
-  return ceil(os::initial_active_processor_count() * cpu_share_in_percent / 100.0);
-}
-
-static uint calculate_nworkers_based_on_heap_size(double reserve_share_in_percent) {
-  const int nworkers = (MaxHeapSize * (reserve_share_in_percent / 100.0)) / ZPageSizeSmall;
-  return MAX2(nworkers, 1);
-}
-
-static uint calculate_nworkers(double cpu_share_in_percent) {
-  // Cap number of workers so that we don't use more than 2% of the max heap
-  // for the small page reserve. This is useful when using small heaps on
-  // large machines.
-  return MIN2(calculate_nworkers_based_on_ncpus(cpu_share_in_percent),
-              calculate_nworkers_based_on_heap_size(2.0));
-}
-
-uint ZWorkers::calculate_nparallel() {
-  // Use 60% of the CPUs, rounded up. We would like to use as many threads as
-  // possible to increase parallelism. However, using a thread count that is
-  // close to the number of processors tends to lead to over-provisioning and
-  // scheduling latency issues. Using 60% of the active processors appears to
-  // be a fairly good balance.
-  return calculate_nworkers(60.0);
-}
-
-uint ZWorkers::calculate_nconcurrent() {
-  // Use 12.5% of the CPUs, rounded up. The number of concurrent threads we
-  // would like to use heavily depends on the type of workload we are running.
-  // Using too many threads will have a negative impact on the application
-  // throughput, while using too few threads will prolong the GC-cycle and
-  // we then risk being out-run by the application. Using 12.5% of the active
-  // processors appears to be a fairly good balance.
-  return calculate_nworkers(12.5);
-}
-
 class ZWorkersInitializeTask : public ZTask {
 private:
   const uint _nworkers;

src/hotspot/share/gc/z/zWorkers.hpp

@@ -37,9 +37,6 @@ class ZWorkers {
   void run(ZTask* task, uint nworkers);
 
 public:
-  static uint calculate_nparallel();
-  static uint calculate_nconcurrent();
-
   ZWorkers();
 
   uint nparallel() const;