< prev index next >

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

Print this page




  24 
  25 #ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
  26 #define SHARE_GC_SHARED_GC_GLOBALS_HPP
  27 
  28 #include "utilities/macros.hpp"
  29 #if INCLUDE_CMSGC
  30 #include "gc/cms/cms_globals.hpp"
  31 #endif
  32 #if INCLUDE_EPSILONGC
  33 #include "gc/epsilon/epsilon_globals.hpp"
  34 #endif
  35 #if INCLUDE_G1GC
  36 #include "gc/g1/g1_globals.hpp"
  37 #endif
  38 #if INCLUDE_PARALLELGC
  39 #include "gc/parallel/parallel_globals.hpp"
  40 #endif
  41 #if INCLUDE_SERIALGC
  42 #include "gc/serial/serial_globals.hpp"
  43 #endif



  44 #if INCLUDE_ZGC
  45 #include "gc/z/z_globals.hpp"
  46 #endif
  47 
  48 #define GC_FLAGS(develop,                                                   \
  49                  develop_pd,                                                \
  50                  product,                                                   \
  51                  product_pd,                                                \
  52                  diagnostic,                                                \
  53                  diagnostic_pd,                                             \
  54                  experimental,                                              \
  55                  notproduct,                                                \
  56                  manageable,                                                \
  57                  product_rw,                                                \
  58                  lp64_product,                                              \
  59                  range,                                                     \
  60                  constraint,                                                \
  61                  writeable)                                                 \
  62                                                                             \
  63   CMSGC_ONLY(GC_CMS_FLAGS(                                                  \


 123     range,                                                                  \
 124     constraint,                                                             \
 125     writeable))                                                             \
 126                                                                             \
 127   SERIALGC_ONLY(GC_SERIAL_FLAGS(                                            \
 128     develop,                                                                \
 129     develop_pd,                                                             \
 130     product,                                                                \
 131     product_pd,                                                             \
 132     diagnostic,                                                             \
 133     diagnostic_pd,                                                          \
 134     experimental,                                                           \
 135     notproduct,                                                             \
 136     manageable,                                                             \
 137     product_rw,                                                             \
 138     lp64_product,                                                           \
 139     range,                                                                  \
 140     constraint,                                                             \
 141     writeable))                                                             \
 142                                                                             \
















 143   ZGC_ONLY(GC_Z_FLAGS(                                                      \
 144     develop,                                                                \
 145     develop_pd,                                                             \
 146     product,                                                                \
 147     product_pd,                                                             \
 148     diagnostic,                                                             \
 149     diagnostic_pd,                                                          \
 150     experimental,                                                           \
 151     notproduct,                                                             \
 152     manageable,                                                             \
 153     product_rw,                                                             \
 154     lp64_product,                                                           \
 155     range,                                                                  \
 156     constraint,                                                             \
 157     writeable))                                                             \
 158                                                                             \
 159   /* gc */                                                                  \
 160                                                                             \
 161   product(bool, UseConcMarkSweepGC, false,                                  \
 162           "Use Concurrent Mark-Sweep GC in the old generation")             \
 163                                                                             \
 164   product(bool, UseSerialGC, false,                                         \
 165           "Use the Serial garbage collector")                               \
 166                                                                             \
 167   product(bool, UseG1GC, false,                                             \
 168           "Use the Garbage-First garbage collector")                        \
 169                                                                             \
 170   product(bool, UseParallelGC, false,                                       \
 171           "Use the Parallel Scavenge garbage collector")                    \
 172                                                                             \
 173   product(bool, UseParallelOldGC, false,                                    \
 174           "Use the Parallel Old garbage collector")                         \
 175                                                                             \
 176   experimental(bool, UseEpsilonGC, false,                                   \
 177           "Use the Epsilon (no-op) garbage collector")                      \
 178                                                                             \
 179   experimental(bool, UseZGC, false,                                         \
 180           "Use the Z garbage collector")                                    \



 181                                                                             \
 182   product(uint, ParallelGCThreads, 0,                                       \
 183           "Number of parallel threads parallel gc will use")                \
 184           constraint(ParallelGCThreadsConstraintFunc,AfterErgo)             \
 185                                                                             \
 186   diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true,              \
 187             "Use semaphore synchronization for the GC Threads, "            \
 188             "instead of synchronization based on mutexes")                  \
 189                                                                             \
 190   product(bool, UseDynamicNumberOfGCThreads, true,                          \
 191           "Dynamically choose the number of threads up to a maximum of "    \
 192           "ParallelGCThreads parallel collectors will use for garbage "     \
 193           "collection work")                                                \
 194                                                                             \
 195   diagnostic(bool, InjectGCWorkerCreationFailure, false,                    \
 196              "Inject thread creation failures for "                         \
 197              "UseDynamicNumberOfGCThreads")                                 \
 198                                                                             \
 199   diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
 200           "Force dynamic selection of the number of "                       \




  24 
  25 #ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
  26 #define SHARE_GC_SHARED_GC_GLOBALS_HPP
  27 
  28 #include "utilities/macros.hpp"
  29 #if INCLUDE_CMSGC
  30 #include "gc/cms/cms_globals.hpp"
  31 #endif
  32 #if INCLUDE_EPSILONGC
  33 #include "gc/epsilon/epsilon_globals.hpp"
  34 #endif
  35 #if INCLUDE_G1GC
  36 #include "gc/g1/g1_globals.hpp"
  37 #endif
  38 #if INCLUDE_PARALLELGC
  39 #include "gc/parallel/parallel_globals.hpp"
  40 #endif
  41 #if INCLUDE_SERIALGC
  42 #include "gc/serial/serial_globals.hpp"
  43 #endif
  44 #if INCLUDE_SHENANDOAHGC
  45 #include "gc/shenandoah/shenandoah_globals.hpp"
  46 #endif
  47 #if INCLUDE_ZGC
  48 #include "gc/z/z_globals.hpp"
  49 #endif
  50 
  51 #define GC_FLAGS(develop,                                                   \
  52                  develop_pd,                                                \
  53                  product,                                                   \
  54                  product_pd,                                                \
  55                  diagnostic,                                                \
  56                  diagnostic_pd,                                             \
  57                  experimental,                                              \
  58                  notproduct,                                                \
  59                  manageable,                                                \
  60                  product_rw,                                                \
  61                  lp64_product,                                              \
  62                  range,                                                     \
  63                  constraint,                                                \
  64                  writeable)                                                 \
  65                                                                             \
  66   CMSGC_ONLY(GC_CMS_FLAGS(                                                  \


 126     range,                                                                  \
 127     constraint,                                                             \
 128     writeable))                                                             \
 129                                                                             \
 130   SERIALGC_ONLY(GC_SERIAL_FLAGS(                                            \
 131     develop,                                                                \
 132     develop_pd,                                                             \
 133     product,                                                                \
 134     product_pd,                                                             \
 135     diagnostic,                                                             \
 136     diagnostic_pd,                                                          \
 137     experimental,                                                           \
 138     notproduct,                                                             \
 139     manageable,                                                             \
 140     product_rw,                                                             \
 141     lp64_product,                                                           \
 142     range,                                                                  \
 143     constraint,                                                             \
 144     writeable))                                                             \
 145                                                                             \
 146   SHENANDOAHGC_ONLY(GC_SHENANDOAH_FLAGS(                                    \
 147     develop,                                                                \
 148     develop_pd,                                                             \
 149     product,                                                                \
 150     product_pd,                                                             \
 151     diagnostic,                                                             \
 152     diagnostic_pd,                                                          \
 153     experimental,                                                           \
 154     notproduct,                                                             \
 155     manageable,                                                             \
 156     product_rw,                                                             \
 157     lp64_product,                                                           \
 158     range,                                                                  \
 159     constraint,                                                             \
 160     writeable))                                                             \
 161                                                                             \
 162   ZGC_ONLY(GC_Z_FLAGS(                                                      \
 163     develop,                                                                \
 164     develop_pd,                                                             \
 165     product,                                                                \
 166     product_pd,                                                             \
 167     diagnostic,                                                             \
 168     diagnostic_pd,                                                          \
 169     experimental,                                                           \
 170     notproduct,                                                             \
 171     manageable,                                                             \
 172     product_rw,                                                             \
 173     lp64_product,                                                           \
 174     range,                                                                  \
 175     constraint,                                                             \
 176     writeable))                                                             \
 177                                                                             \
 178   /* gc */                                                                  \
 179                                                                             \
 180   product(bool, UseConcMarkSweepGC, false,                                  \
 181           "Use Concurrent Mark-Sweep GC in the old generation")             \
 182                                                                             \
 183   product(bool, UseSerialGC, false,                                         \
 184           "Use the Serial garbage collector")                               \
 185                                                                             \
 186   product(bool, UseG1GC, false,                                             \
 187           "Use the Garbage-First garbage collector")                        \
 188                                                                             \
 189   product(bool, UseParallelGC, false,                                       \
 190           "Use the Parallel Scavenge garbage collector")                    \
 191                                                                             \
 192   product(bool, UseParallelOldGC, false,                                    \
 193           "Use the Parallel Old garbage collector")                         \
 194                                                                             \
 195   experimental(bool, UseEpsilonGC, false,                                   \
 196           "Use the Epsilon (no-op) garbage collector")                      \
 197                                                                             \
 198   experimental(bool, UseZGC, false,                                         \
 199           "Use the Z garbage collector")                                    \
 200                                                                             \
 201   product(bool, UseShenandoahGC, false,                                     \
 202           "Use the Shenandoah garbage collector")                           \
 203                                                                             \
 204   product(uint, ParallelGCThreads, 0,                                       \
 205           "Number of parallel threads parallel gc will use")                \
 206           constraint(ParallelGCThreadsConstraintFunc,AfterErgo)             \
 207                                                                             \
 208   diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true,              \
 209             "Use semaphore synchronization for the GC Threads, "            \
 210             "instead of synchronization based on mutexes")                  \
 211                                                                             \
 212   product(bool, UseDynamicNumberOfGCThreads, true,                          \
 213           "Dynamically choose the number of threads up to a maximum of "    \
 214           "ParallelGCThreads parallel collectors will use for garbage "     \
 215           "collection work")                                                \
 216                                                                             \
 217   diagnostic(bool, InjectGCWorkerCreationFailure, false,                    \
 218              "Inject thread creation failures for "                         \
 219              "UseDynamicNumberOfGCThreads")                                 \
 220                                                                             \
 221   diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
 222           "Force dynamic selection of the number of "                       \


< prev index next >