< prev index next >

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

Print this page
   1 /*
   2  * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *


  41 #endif
  42 #if INCLUDE_SHENANDOAHGC
  43 #include "gc/shenandoah/shenandoah_globals.hpp"
  44 #endif
  45 #if INCLUDE_ZGC
  46 #include "gc/z/z_globals.hpp"
  47 #endif
  48 
  49 #define GC_FLAGS(develop,                                                   \
  50                  develop_pd,                                                \
  51                  product,                                                   \
  52                  product_pd,                                                \
  53                  diagnostic,                                                \
  54                  diagnostic_pd,                                             \
  55                  experimental,                                              \
  56                  notproduct,                                                \
  57                  manageable,                                                \
  58                  product_rw,                                                \
  59                  lp64_product,                                              \
  60                  range,                                                     \
  61                  constraint,                                                \
  62                  writeable)                                                 \
  63                                                                             \
  64   EPSILONGC_ONLY(GC_EPSILON_FLAGS(                                          \
  65     develop,                                                                \
  66     develop_pd,                                                             \
  67     product,                                                                \
  68     product_pd,                                                             \
  69     diagnostic,                                                             \
  70     diagnostic_pd,                                                          \
  71     experimental,                                                           \
  72     notproduct,                                                             \
  73     manageable,                                                             \
  74     product_rw,                                                             \
  75     lp64_product,                                                           \
  76     range,                                                                  \
  77     constraint,                                                             \
  78     writeable))                                                             \
  79                                                                             \
  80   G1GC_ONLY(GC_G1_FLAGS(                                                    \
  81     develop,                                                                \
  82     develop_pd,                                                             \
  83     product,                                                                \
  84     product_pd,                                                             \
  85     diagnostic,                                                             \
  86     diagnostic_pd,                                                          \
  87     experimental,                                                           \
  88     notproduct,                                                             \
  89     manageable,                                                             \
  90     product_rw,                                                             \
  91     lp64_product,                                                           \
  92     range,                                                                  \
  93     constraint,                                                             \
  94     writeable))                                                             \
  95                                                                             \
  96   PARALLELGC_ONLY(GC_PARALLEL_FLAGS(                                        \
  97     develop,                                                                \
  98     develop_pd,                                                             \
  99     product,                                                                \
 100     product_pd,                                                             \
 101     diagnostic,                                                             \
 102     diagnostic_pd,                                                          \
 103     experimental,                                                           \
 104     notproduct,                                                             \
 105     manageable,                                                             \
 106     product_rw,                                                             \
 107     lp64_product,                                                           \
 108     range,                                                                  \
 109     constraint,                                                             \
 110     writeable))                                                             \
 111                                                                             \
 112   SERIALGC_ONLY(GC_SERIAL_FLAGS(                                            \
 113     develop,                                                                \
 114     develop_pd,                                                             \
 115     product,                                                                \
 116     product_pd,                                                             \
 117     diagnostic,                                                             \
 118     diagnostic_pd,                                                          \
 119     experimental,                                                           \
 120     notproduct,                                                             \
 121     manageable,                                                             \
 122     product_rw,                                                             \
 123     lp64_product,                                                           \
 124     range,                                                                  \
 125     constraint,                                                             \
 126     writeable))                                                             \
 127                                                                             \
 128   SHENANDOAHGC_ONLY(GC_SHENANDOAH_FLAGS(                                    \
 129     develop,                                                                \
 130     develop_pd,                                                             \
 131     product,                                                                \
 132     product_pd,                                                             \
 133     diagnostic,                                                             \
 134     diagnostic_pd,                                                          \
 135     experimental,                                                           \
 136     notproduct,                                                             \
 137     manageable,                                                             \
 138     product_rw,                                                             \
 139     lp64_product,                                                           \
 140     range,                                                                  \
 141     constraint,                                                             \
 142     writeable))                                                             \
 143                                                                             \
 144   ZGC_ONLY(GC_Z_FLAGS(                                                      \
 145     develop,                                                                \
 146     develop_pd,                                                             \
 147     product,                                                                \
 148     product_pd,                                                             \
 149     diagnostic,                                                             \
 150     diagnostic_pd,                                                          \
 151     experimental,                                                           \
 152     notproduct,                                                             \
 153     manageable,                                                             \
 154     product_rw,                                                             \
 155     lp64_product,                                                           \
 156     range,                                                                  \
 157     constraint,                                                             \
 158     writeable))                                                             \
 159                                                                             \
 160   /* gc */                                                                  \
 161                                                                             \
 162   product(bool, UseSerialGC, false,                                         \
 163           "Use the Serial garbage collector")                               \
 164                                                                             \
 165   product(bool, UseG1GC, false,                                             \
 166           "Use the Garbage-First garbage collector")                        \
 167                                                                             \
 168   product(bool, UseParallelGC, false,                                       \
 169           "Use the Parallel garbage collector.")                            \
 170                                                                             \
 171   product(bool, UseParallelOldGC, false,                                    \
 172           "Use the Parallel or Serial garbage collector when collecting "   \
 173           "the old generation. Deprecated.")                                \
 174                                                                             \
 175   experimental(bool, UseEpsilonGC, false,                                   \
 176           "Use the Epsilon (no-op) garbage collector")                      \
 177                                                                             \
 178   experimental(bool, UseZGC, false,                                         \


   1 /*
   2  * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *


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

  62                                                                             \
  63   EPSILONGC_ONLY(GC_EPSILON_FLAGS(                                          \
  64     develop,                                                                \
  65     develop_pd,                                                             \
  66     product,                                                                \
  67     product_pd,                                                             \
  68     diagnostic,                                                             \
  69     diagnostic_pd,                                                          \
  70     experimental,                                                           \
  71     notproduct,                                                             \
  72     manageable,                                                             \
  73     product_rw,                                                             \
  74     lp64_product,                                                           \
  75     range,                                                                  \
  76     constraint))                                                            \

  77                                                                             \
  78   G1GC_ONLY(GC_G1_FLAGS(                                                    \
  79     develop,                                                                \
  80     develop_pd,                                                             \
  81     product,                                                                \
  82     product_pd,                                                             \
  83     diagnostic,                                                             \
  84     diagnostic_pd,                                                          \
  85     experimental,                                                           \
  86     notproduct,                                                             \
  87     manageable,                                                             \
  88     product_rw,                                                             \
  89     lp64_product,                                                           \
  90     range,                                                                  \
  91     constraint))                                                            \

  92                                                                             \
  93   PARALLELGC_ONLY(GC_PARALLEL_FLAGS(                                        \
  94     develop,                                                                \
  95     develop_pd,                                                             \
  96     product,                                                                \
  97     product_pd,                                                             \
  98     diagnostic,                                                             \
  99     diagnostic_pd,                                                          \
 100     experimental,                                                           \
 101     notproduct,                                                             \
 102     manageable,                                                             \
 103     product_rw,                                                             \
 104     lp64_product,                                                           \
 105     range,                                                                  \
 106     constraint))                                                            \

 107                                                                             \
 108   SERIALGC_ONLY(GC_SERIAL_FLAGS(                                            \
 109     develop,                                                                \
 110     develop_pd,                                                             \
 111     product,                                                                \
 112     product_pd,                                                             \
 113     diagnostic,                                                             \
 114     diagnostic_pd,                                                          \
 115     experimental,                                                           \
 116     notproduct,                                                             \
 117     manageable,                                                             \
 118     product_rw,                                                             \
 119     lp64_product,                                                           \
 120     range,                                                                  \
 121     constraint))                                                            \

 122                                                                             \
 123   SHENANDOAHGC_ONLY(GC_SHENANDOAH_FLAGS(                                    \
 124     develop,                                                                \
 125     develop_pd,                                                             \
 126     product,                                                                \
 127     product_pd,                                                             \
 128     diagnostic,                                                             \
 129     diagnostic_pd,                                                          \
 130     experimental,                                                           \
 131     notproduct,                                                             \
 132     manageable,                                                             \
 133     product_rw,                                                             \
 134     lp64_product,                                                           \
 135     range,                                                                  \
 136     constraint))                                                            \

 137                                                                             \
 138   ZGC_ONLY(GC_Z_FLAGS(                                                      \
 139     develop,                                                                \
 140     develop_pd,                                                             \
 141     product,                                                                \
 142     product_pd,                                                             \
 143     diagnostic,                                                             \
 144     diagnostic_pd,                                                          \
 145     experimental,                                                           \
 146     notproduct,                                                             \
 147     manageable,                                                             \
 148     product_rw,                                                             \
 149     lp64_product,                                                           \
 150     range,                                                                  \
 151     constraint))                                                            \

 152                                                                             \
 153   /* gc */                                                                  \
 154                                                                             \
 155   product(bool, UseSerialGC, false,                                         \
 156           "Use the Serial garbage collector")                               \
 157                                                                             \
 158   product(bool, UseG1GC, false,                                             \
 159           "Use the Garbage-First garbage collector")                        \
 160                                                                             \
 161   product(bool, UseParallelGC, false,                                       \
 162           "Use the Parallel garbage collector.")                            \
 163                                                                             \
 164   product(bool, UseParallelOldGC, false,                                    \
 165           "Use the Parallel or Serial garbage collector when collecting "   \
 166           "the old generation. Deprecated.")                                \
 167                                                                             \
 168   experimental(bool, UseEpsilonGC, false,                                   \
 169           "Use the Epsilon (no-op) garbage collector")                      \
 170                                                                             \
 171   experimental(bool, UseZGC, false,                                         \


< prev index next >