src/hotspot/share/gc/shared/gc_globals.hpp
changeset 59053 ba6c248cae19
parent 57777 90ead0febf56
child 59115 a129f10e1b9a
equal deleted inserted replaced
59051:f0312c7d5b37 59053:ba6c248cae19
    25 #ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
    25 #ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
    26 #define SHARE_GC_SHARED_GC_GLOBALS_HPP
    26 #define SHARE_GC_SHARED_GC_GLOBALS_HPP
    27 
    27 
    28 #include "runtime/globals_shared.hpp"
    28 #include "runtime/globals_shared.hpp"
    29 #include "utilities/macros.hpp"
    29 #include "utilities/macros.hpp"
    30 #if INCLUDE_CMSGC
       
    31 #include "gc/cms/cms_globals.hpp"
       
    32 #endif
       
    33 #if INCLUDE_EPSILONGC
    30 #if INCLUDE_EPSILONGC
    34 #include "gc/epsilon/epsilon_globals.hpp"
    31 #include "gc/epsilon/epsilon_globals.hpp"
    35 #endif
    32 #endif
    36 #if INCLUDE_G1GC
    33 #if INCLUDE_G1GC
    37 #include "gc/g1/g1_globals.hpp"
    34 #include "gc/g1/g1_globals.hpp"
    62                  lp64_product,                                              \
    59                  lp64_product,                                              \
    63                  range,                                                     \
    60                  range,                                                     \
    64                  constraint,                                                \
    61                  constraint,                                                \
    65                  writeable)                                                 \
    62                  writeable)                                                 \
    66                                                                             \
    63                                                                             \
    67   CMSGC_ONLY(GC_CMS_FLAGS(                                                  \
       
    68     develop,                                                                \
       
    69     develop_pd,                                                             \
       
    70     product,                                                                \
       
    71     product_pd,                                                             \
       
    72     diagnostic,                                                             \
       
    73     diagnostic_pd,                                                          \
       
    74     experimental,                                                           \
       
    75     notproduct,                                                             \
       
    76     manageable,                                                             \
       
    77     product_rw,                                                             \
       
    78     lp64_product,                                                           \
       
    79     range,                                                                  \
       
    80     constraint,                                                             \
       
    81     writeable))                                                             \
       
    82                                                                             \
       
    83   EPSILONGC_ONLY(GC_EPSILON_FLAGS(                                          \
    64   EPSILONGC_ONLY(GC_EPSILON_FLAGS(                                          \
    84     develop,                                                                \
    65     develop,                                                                \
    85     develop_pd,                                                             \
    66     develop_pd,                                                             \
    86     product,                                                                \
    67     product,                                                                \
    87     product_pd,                                                             \
    68     product_pd,                                                             \
   176     constraint,                                                             \
   157     constraint,                                                             \
   177     writeable))                                                             \
   158     writeable))                                                             \
   178                                                                             \
   159                                                                             \
   179   /* gc */                                                                  \
   160   /* gc */                                                                  \
   180                                                                             \
   161                                                                             \
   181   product(bool, UseConcMarkSweepGC, false,                                  \
       
   182           "Use Concurrent Mark-Sweep GC in the old generation")             \
       
   183                                                                             \
       
   184   product(bool, UseSerialGC, false,                                         \
   162   product(bool, UseSerialGC, false,                                         \
   185           "Use the Serial garbage collector")                               \
   163           "Use the Serial garbage collector")                               \
   186                                                                             \
   164                                                                             \
   187   product(bool, UseG1GC, false,                                             \
   165   product(bool, UseG1GC, false,                                             \
   188           "Use the Garbage-First garbage collector")                        \
   166           "Use the Garbage-First garbage collector")                        \
   284   product(int, ParGCArrayScanChunk, 50,                                     \
   262   product(int, ParGCArrayScanChunk, 50,                                     \
   285           "Scan a subset of object array and push remainder, if array is "  \
   263           "Scan a subset of object array and push remainder, if array is "  \
   286           "bigger than this")                                               \
   264           "bigger than this")                                               \
   287           range(1, max_jint/3)                                              \
   265           range(1, max_jint/3)                                              \
   288                                                                             \
   266                                                                             \
   289   product(uintx, OldPLABWeight, 50,                                         \
       
   290           "Percentage (0-100) used to weight the current sample when "      \
       
   291           "computing exponentially decaying average for resizing "          \
       
   292           "OldPLABSize")                                                    \
       
   293           range(0, 100)                                                     \
       
   294                                                                             \
       
   295   product(bool, ResizeOldPLAB, true,                                        \
       
   296           "Dynamically resize (old gen) promotion LAB's")                   \
       
   297                                                                             \
   267                                                                             \
   298   product(bool, AlwaysPreTouch, false,                                      \
   268   product(bool, AlwaysPreTouch, false,                                      \
   299           "Force all freshly committed pages to be pre-touched")            \
   269           "Force all freshly committed pages to be pre-touched")            \
   300                                                                             \
   270                                                                             \
   301   product(size_t, PreTouchParallelChunkSize, 1 * G,                         \
   271   product(size_t, PreTouchParallelChunkSize, 1 * G,                         \
   308           range(1, (max_jint - 1))                                          \
   278           range(1, (max_jint - 1))                                          \
   309                                                                             \
   279                                                                             \
   310   product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M),             \
   280   product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M),             \
   311           "Size of marking stack")                                          \
   281           "Size of marking stack")                                          \
   312           constraint(MarkStackSizeConstraintFunc,AfterErgo)                 \
   282           constraint(MarkStackSizeConstraintFunc,AfterErgo)                 \
   313                                                                             \
       
   314   develop(bool, VerifyBlockOffsetArray, false,                              \
       
   315           "Do (expensive) block offset array verification")                 \
       
   316                                                                             \
       
   317   diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false,              \
       
   318           "Maintain _unallocated_block in BlockOffsetArray "                \
       
   319           "(currently applicable only to CMS collector)")                   \
       
   320                                                                             \
   283                                                                             \
   321   product(intx, RefDiscoveryPolicy, 0,                                      \
   284   product(intx, RefDiscoveryPolicy, 0,                                      \
   322           "Select type of reference discovery policy: "                     \
   285           "Select type of reference discovery policy: "                     \
   323           "reference-based(0) or referent-based(1)")                        \
   286           "reference-based(0) or referent-based(1)")                        \
   324           range(ReferenceProcessor::DiscoveryPolicyMin,                     \
   287           range(ReferenceProcessor::DiscoveryPolicyMin,                     \
   362   notproduct(bool, PromotionFailureALot, false,                             \
   325   notproduct(bool, PromotionFailureALot, false,                             \
   363           "Use promotion failure handling on every youngest generation "    \
   326           "Use promotion failure handling on every youngest generation "    \
   364           "collection")                                                     \
   327           "collection")                                                     \
   365                                                                             \
   328                                                                             \
   366   develop(uintx, PromotionFailureALotCount, 1000,                           \
   329   develop(uintx, PromotionFailureALotCount, 1000,                           \
   367           "Number of promotion failures occurring at PLAB "                 \
   330           "Number of promotion failures occurring at PLAB promotion "       \
   368           "refill attempts (ParNew) or promotion attempts "                 \
   331           "attempts at young collectors")                                   \
   369           "(other young collectors)")                                       \
       
   370                                                                             \
   332                                                                             \
   371   develop(uintx, PromotionFailureALotInterval, 5,                           \
   333   develop(uintx, PromotionFailureALotInterval, 5,                           \
   372           "Total collections between promotion failures a lot")             \
   334           "Total collections between promotion failures a lot")             \
   373                                                                             \
   335                                                                             \
   374   diagnostic(bool, UseOWSTTaskTerminator, true,                             \
   336   diagnostic(bool, UseOWSTTaskTerminator, true,                             \
   757   product(size_t, YoungPLABSize, 4096,                                      \
   719   product(size_t, YoungPLABSize, 4096,                                      \
   758           "Size of young gen promotion LAB's (in HeapWords)")               \
   720           "Size of young gen promotion LAB's (in HeapWords)")               \
   759           constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit)           \
   721           constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit)           \
   760                                                                             \
   722                                                                             \
   761   product(size_t, OldPLABSize, 1024,                                        \
   723   product(size_t, OldPLABSize, 1024,                                        \
   762           "Size of old gen promotion LAB's (in HeapWords), or Number "      \
   724           "Size of old gen promotion LAB's (in HeapWords)")                 \
   763           "of blocks to attempt to claim when refilling CMS LAB's")         \
       
   764           constraint(OldPLABSizeConstraintFunc,AfterMemoryInit)             \
   725           constraint(OldPLABSizeConstraintFunc,AfterMemoryInit)             \
   765                                                                             \
   726                                                                             \
   766   product(uintx, TLABAllocationWeight, 35,                                  \
   727   product(uintx, TLABAllocationWeight, 35,                                  \
   767           "Allocation averaging weight")                                    \
   728           "Allocation averaging weight")                                    \
   768           range(0, 100)                                                     \
   729           range(0, 100)                                                     \
   825                                                                             \
   786                                                                             \
   826   product(uintx, MarkSweepDeadRatio,     5,                                 \
   787   product(uintx, MarkSweepDeadRatio,     5,                                 \
   827           "Percentage (0-100) of the old gen allowed as dead wood. "        \
   788           "Percentage (0-100) of the old gen allowed as dead wood. "        \
   828           "Serial mark sweep treats this as both the minimum and maximum "  \
   789           "Serial mark sweep treats this as both the minimum and maximum "  \
   829           "value. "                                                         \
   790           "value. "                                                         \
   830           "CMS uses this value only if it falls back to mark sweep. "       \
       
   831           "Par compact uses a variable scale based on the density of the "  \
   791           "Par compact uses a variable scale based on the density of the "  \
   832           "generation and treats this as the maximum value when the heap "  \
   792           "generation and treats this as the maximum value when the heap "  \
   833           "is either completely full or completely empty.  Par compact "    \
   793           "is either completely full or completely empty.  Par compact "    \
   834           "also has a smaller default value; see arguments.cpp.")           \
   794           "also has a smaller default value; see arguments.cpp.")           \
   835           range(0, 100)                                                     \
   795           range(0, 100)                                                     \