src/share/vm/gc_implementation/g1/g1_globals.hpp

Print this page
rev 4561 : 7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
Summary: Refactor G1's hot card cache and card counts table into their own files. Simplify the card counts table, including removing the encoding of the card index in each entry. The card counts table now has a 1:1 correspondence with the cards spanned by heap. Space for the card counts table is reserved from virtual memory (rather than C heap) during JVM startup and is committed/expanded when the heap is expanded. Changes were also reviewed-by Vitaly Davidovich.
Reviewed-by:


 146           "concurrent processing threads. Will be selected ergonomically "  \
 147           "by default.")                                                    \
 148                                                                             \
 149   product(intx, G1ConcRefinementServiceIntervalMillis, 300,                 \
 150           "The last concurrent refinement thread wakes up every "           \
 151           "specified number of milliseconds to do miscellaneous work.")     \
 152                                                                             \
 153   product(intx, G1ConcRefinementThresholdStep, 0,                           \
 154           "Each time the rset update queue increases by this amount "       \
 155           "activate the next refinement thread if available. "              \
 156           "Will be selected ergonomically by default.")                     \
 157                                                                             \
 158   product(intx, G1RSetUpdatingPauseTimePercent, 10,                         \
 159           "A target percentage of time that is allowed to be spend on "     \
 160           "process RS update buffers during the collection pause.")         \
 161                                                                             \
 162   product(bool, G1UseAdaptiveConcRefinement, true,                          \
 163           "Select green, yellow and red zones adaptively to meet the "      \
 164           "the pause requirements.")                                        \
 165                                                                             \
 166   develop(intx, G1ConcRSLogCacheSize, 10,                                   \
 167           "Log base 2 of the length of conc RS hot-card cache.")            \
 168                                                                             \
 169   develop(intx, G1ConcRSHotCardLimit, 4,                                    \
 170           "The threshold that defines (>=) a hot card.")                    \
 171                                                                             \
 172   develop(intx, G1MaxHotCardCountSizePercent, 25,                           \
 173           "The maximum size of the hot card count cache as a "              \
 174           "percentage of the number of cards for the maximum heap.")        \
 175                                                                             \
 176   develop(bool, G1PrintOopAppls, false,                                     \
 177           "When true, print applications of closures to external locs.")    \
 178                                                                             \
 179   develop(intx, G1RSetRegionEntriesBase, 256,                               \
 180           "Max number of regions in a fine-grain table per MB.")            \
 181                                                                             \
 182   product(intx, G1RSetRegionEntries, 0,                                     \
 183           "Max number of regions for which we keep bitmaps."                \
 184           "Will be set ergonomically by default")                           \
 185                                                                             \
 186   develop(intx, G1RSetSparseRegionEntriesBase, 4,                           \
 187           "Max number of entries per region in a sparse table "             \
 188           "per MB.")                                                        \
 189                                                                             \
 190   product(intx, G1RSetSparseRegionEntries, 0,                               \
 191           "Max number of entries per region in a sparse table."             \
 192           "Will be set ergonomically by default.")                          \
 193                                                                             \
 194   develop(bool, G1RecordHRRSOops, false,                                    \
 195           "When true, record recent calls to rem set operations.")          \


 230                                                                             \
 231   develop(bool, G1FailOnFPError, false,                                     \
 232           "When set, G1 will fail when it encounters an FP 'error', "       \
 233           "so as to allow debugging")                                       \
 234                                                                             \
 235   product(uintx, G1HeapRegionSize, 0,                                       \
 236           "Size of the G1 regions.")                                        \
 237                                                                             \
 238   experimental(bool, G1UseParallelRSetUpdating, true,                       \
 239           "Enables the parallelization of remembered set updating "         \
 240           "during evacuation pauses")                                       \
 241                                                                             \
 242   experimental(bool, G1UseParallelRSetScanning, true,                       \
 243           "Enables the parallelization of remembered set scanning "         \
 244           "during evacuation pauses")                                       \
 245                                                                             \
 246   product(uintx, G1ConcRefinementThreads, 0,                                \
 247           "If non-0 is the number of parallel rem set update threads, "     \
 248           "otherwise the value is determined ergonomically.")               \
 249                                                                             \
 250   develop(intx, G1CardCountCacheExpandThreshold, 16,                        \
 251           "Expand the card count cache if the number of collisions for "    \
 252           "a particular entry exceeds this value.")                         \
 253                                                                             \
 254   develop(bool, G1VerifyCTCleanup, false,                                   \
 255           "Verify card table cleanup.")                                     \
 256                                                                             \
 257   product(uintx, G1RSetScanBlockSize, 64,                                   \
 258           "Size of a work unit of cards claimed by a worker thread"         \
 259           "during RSet scanning.")                                          \
 260                                                                             \
 261   develop(uintx, G1SecondaryFreeListAppendLength, 5,                        \
 262           "The number of regions we will add to the secondary free list "   \
 263           "at every append operation")                                      \
 264                                                                             \
 265   develop(bool, G1ConcRegionFreeingVerbose, false,                          \
 266           "Enables verboseness during concurrent region freeing")           \
 267                                                                             \
 268   develop(bool, G1StressConcRegionFreeing, false,                           \
 269           "It stresses the concurrent region freeing operation")            \
 270                                                                             \
 271   develop(uintx, G1StressConcRegionFreeingDelayMillis, 0,                   \
 272           "Artificial delay during concurrent region freeing")              \
 273                                                                             \




 146           "concurrent processing threads. Will be selected ergonomically "  \
 147           "by default.")                                                    \
 148                                                                             \
 149   product(intx, G1ConcRefinementServiceIntervalMillis, 300,                 \
 150           "The last concurrent refinement thread wakes up every "           \
 151           "specified number of milliseconds to do miscellaneous work.")     \
 152                                                                             \
 153   product(intx, G1ConcRefinementThresholdStep, 0,                           \
 154           "Each time the rset update queue increases by this amount "       \
 155           "activate the next refinement thread if available. "              \
 156           "Will be selected ergonomically by default.")                     \
 157                                                                             \
 158   product(intx, G1RSetUpdatingPauseTimePercent, 10,                         \
 159           "A target percentage of time that is allowed to be spend on "     \
 160           "process RS update buffers during the collection pause.")         \
 161                                                                             \
 162   product(bool, G1UseAdaptiveConcRefinement, true,                          \
 163           "Select green, yellow and red zones adaptively to meet the "      \
 164           "the pause requirements.")                                        \
 165                                                                             \
 166   product(uintx, G1ConcRSLogCacheSize, 10,                                  \
 167           "Log base 2 of the length of conc RS hot-card cache.")            \
 168                                                                             \
 169   product(uintx, G1ConcRSHotCardLimit, 4,                                   \
 170           "The threshold that defines (>=) a hot card.")                    \
 171                                                                             \




 172   develop(bool, G1PrintOopAppls, false,                                     \
 173           "When true, print applications of closures to external locs.")    \
 174                                                                             \
 175   develop(intx, G1RSetRegionEntriesBase, 256,                               \
 176           "Max number of regions in a fine-grain table per MB.")            \
 177                                                                             \
 178   product(intx, G1RSetRegionEntries, 0,                                     \
 179           "Max number of regions for which we keep bitmaps."                \
 180           "Will be set ergonomically by default")                           \
 181                                                                             \
 182   develop(intx, G1RSetSparseRegionEntriesBase, 4,                           \
 183           "Max number of entries per region in a sparse table "             \
 184           "per MB.")                                                        \
 185                                                                             \
 186   product(intx, G1RSetSparseRegionEntries, 0,                               \
 187           "Max number of entries per region in a sparse table."             \
 188           "Will be set ergonomically by default.")                          \
 189                                                                             \
 190   develop(bool, G1RecordHRRSOops, false,                                    \
 191           "When true, record recent calls to rem set operations.")          \


 226                                                                             \
 227   develop(bool, G1FailOnFPError, false,                                     \
 228           "When set, G1 will fail when it encounters an FP 'error', "       \
 229           "so as to allow debugging")                                       \
 230                                                                             \
 231   product(uintx, G1HeapRegionSize, 0,                                       \
 232           "Size of the G1 regions.")                                        \
 233                                                                             \
 234   experimental(bool, G1UseParallelRSetUpdating, true,                       \
 235           "Enables the parallelization of remembered set updating "         \
 236           "during evacuation pauses")                                       \
 237                                                                             \
 238   experimental(bool, G1UseParallelRSetScanning, true,                       \
 239           "Enables the parallelization of remembered set scanning "         \
 240           "during evacuation pauses")                                       \
 241                                                                             \
 242   product(uintx, G1ConcRefinementThreads, 0,                                \
 243           "If non-0 is the number of parallel rem set update threads, "     \
 244           "otherwise the value is determined ergonomically.")               \
 245                                                                             \




 246   develop(bool, G1VerifyCTCleanup, false,                                   \
 247           "Verify card table cleanup.")                                     \
 248                                                                             \
 249   product(uintx, G1RSetScanBlockSize, 64,                                   \
 250           "Size of a work unit of cards claimed by a worker thread"         \
 251           "during RSet scanning.")                                          \
 252                                                                             \
 253   develop(uintx, G1SecondaryFreeListAppendLength, 5,                        \
 254           "The number of regions we will add to the secondary free list "   \
 255           "at every append operation")                                      \
 256                                                                             \
 257   develop(bool, G1ConcRegionFreeingVerbose, false,                          \
 258           "Enables verboseness during concurrent region freeing")           \
 259                                                                             \
 260   develop(bool, G1StressConcRegionFreeing, false,                           \
 261           "It stresses the concurrent region freeing operation")            \
 262                                                                             \
 263   develop(uintx, G1StressConcRegionFreeingDelayMillis, 0,                   \
 264           "Artificial delay during concurrent region freeing")              \
 265                                                                             \