< prev index next >

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

Print this page

@@ -23,48 +23,39 @@
  */
 
 #ifndef SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
 #define SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
 
-#define GC_PARALLEL_FLAGS(develop,                                          \
-                          develop_pd,                                       \
-                          product,                                          \
-                          product_pd,                                       \
-                          diagnostic,                                       \
-                          diagnostic_pd,                                    \
-                          experimental,                                     \
-                          notproduct,                                       \
-                          manageable,                                       \
-                          product_rw,                                       \
-                          lp64_product,                                     \
-                          range,                                            \
-                          constraint)                                       \
-  product(uintx, HeapMaximumCompactionInterval, 20,                         \
-          "How often should we maximally compact the heap (not allowing "   \
-          "any dead space)")                                                \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, HeapFirstMaximumCompactionCount, 3,                        \
-          "The collection count for the first maximum compaction")          \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(bool, UseMaximumCompactionOnSystemGC, true,                       \
-          "Use maximum compaction in the Parallel Old garbage collector "   \
-          "for a system GC")                                                \
-                                                                            \
-  product(size_t, ParallelOldDeadWoodLimiterMean, 50,                       \
-          "The mean used by the parallel compact dead wood "                \
-          "limiter (a number between 0-100)")                               \
-          range(0, 100)                                                     \
-                                                                            \
-  product(size_t, ParallelOldDeadWoodLimiterStdDev, 80,                     \
-          "The standard deviation used by the parallel compact dead wood "  \
-          "limiter (a number between 0-100)")                               \
-          range(0, 100)                                                     \
-                                                                            \
-  develop(uintx, GCWorkerDelayMillis, 0,                                    \
-          "Delay in scheduling GC workers (in milliseconds)")               \
-                                                                            \
-  product(bool, PSChunkLargeArrays, true,                                   \
-          "Process large arrays in chunks")
+#include "utilities/macros.hpp"
+#if INCLUDE_PARALLELGC
+#include "runtime/flags/jvmFlag.hpp"
+PRODUCT_FLAG(uintx,    HeapMaximumCompactionInterval, 20, JVMFlag::RANGE,
+                       "How often should we maximally compact the heap (not allowing "
+                       "any dead space)");
+   FLAG_RANGE(         HeapMaximumCompactionInterval, 0, max_uintx);
+
+PRODUCT_FLAG(uintx,    HeapFirstMaximumCompactionCount, 3, JVMFlag::RANGE,
+                       "The collection count for the first maximum compaction");
+   FLAG_RANGE(         HeapFirstMaximumCompactionCount, 0, max_uintx);
+
+PRODUCT_FLAG(bool,     UseMaximumCompactionOnSystemGC, true, JVMFlag::DEFAULT,
+                       "Use maximum compaction in the Parallel Old garbage collector "
+                       "for a system GC");
+
+PRODUCT_FLAG(size_t,   ParallelOldDeadWoodLimiterMean, 50, JVMFlag::RANGE,
+                       "The mean used by the parallel compact dead wood "
+                       "limiter (a number between 0-100)");
+   FLAG_RANGE(         ParallelOldDeadWoodLimiterMean, 0, 100);
+
+PRODUCT_FLAG(size_t,   ParallelOldDeadWoodLimiterStdDev, 80, JVMFlag::RANGE,
+                       "The standard deviation used by the parallel compact dead wood "
+                       "limiter (a number between 0-100)");
+   FLAG_RANGE(         ParallelOldDeadWoodLimiterStdDev, 0, 100);
+
+DEVELOP_FLAG(uintx,    GCWorkerDelayMillis, 0, JVMFlag::DEFAULT,
+                       "Delay in scheduling GC workers (in milliseconds)");
+
+PRODUCT_FLAG(bool,     PSChunkLargeArrays, true, JVMFlag::DEFAULT,
+                       "Process large arrays in chunks");
+#endif // INCLUDE_PARALLELGC
 
 #endif // SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
< prev index next >