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

25 26 27 28
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1_GLOBALS_HPP
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1_GLOBALS_HPP

#include "runtime/globals.hpp"
29 30 31 32
//
// Defines all globals flags used by the garbage-first compiler.
//

33
#define G1_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw) \
34
                                                                            \
35
  product(uintx, G1ConfidencePercent, 50,                                   \
36 37
          "Confidence level for MMU/pause predictions")                     \
                                                                            \
38
  develop(intx, G1MarkingOverheadPercent, 0,                                \
39 40 41 42 43
          "Overhead of concurrent marking")                                 \
                                                                            \
  develop(intx, G1MarkingVerboseLevel, 0,                                   \
          "Level (0-4) of verboseness of the marking code")                 \
                                                                            \
44 45 46 47 48 49 50 51
  develop(bool, G1PrintReachableAtInitialMark, false,                       \
          "Reachable object dump at the initial mark pause")                \
                                                                            \
  develop(bool, G1VerifyDuringGCPrintReachable, false,                      \
          "If conc mark verification fails, dump reachable objects")        \
                                                                            \
  develop(ccstr, G1PrintReachableBaseFile, NULL,                            \
          "The base file name for the reachable object dumps")              \
52 53 54 55
                                                                            \
  develop(bool, G1TraceMarkStackOverflow, false,                            \
          "If true, extra debugging code for CM restart for ovflw.")        \
                                                                            \
56 57 58
  develop(bool, G1TraceHeapRegionRememberedSet, false,                      \
          "Enables heap region remembered set debug logs")                  \
                                                                            \
59
  diagnostic(bool, G1SummarizeConcMark, false,                              \
60 61
          "Summarize concurrent mark info")                                 \
                                                                            \
J
johnc 已提交
62
  diagnostic(bool, G1SummarizeRSetStats, false,                             \
63 64
          "Summarize remembered set processing info")                       \
                                                                            \
65 66 67 68 69 70
  diagnostic(intx, G1SummarizeRSetStatsPeriod, 0,                           \
          "The period (in number of GCs) at which we will generate "        \
          "update buffer processing info "                                  \
          "(0 means do not periodically generate this info); "              \
          "it also requires -XX:+G1SummarizeRSetStats")                     \
                                                                            \
71
  diagnostic(bool, G1TraceConcRefinement, false,                            \
72 73
          "Trace G1 concurrent refinement")                                 \
                                                                            \
74 75 76 77 78 79 80 81
  product(double, G1ConcMarkStepDurationMillis, 10.0,                       \
          "Target duration of individual concurrent marking steps "         \
          "in milliseconds.")                                               \
                                                                            \
  product(intx, G1RefProcDrainInterval, 10,                                 \
          "The number of discovered reference objects to process before "   \
          "draining concurrent marking work queues.")                       \
                                                                            \
82
  experimental(bool, G1UseConcMarkReferenceProcessing, true,                \
83
          "If true, enable reference discovery during concurrent "          \
84
          "marking and reference processing at the end of remark.")         \
85
                                                                            \
86
  product(intx, G1SATBBufferSize, 1*K,                                      \
87 88
          "Number of entries in an SATB log buffer.")                       \
                                                                            \
89
  develop(intx, G1SATBProcessCompletedThreshold, 20,                        \
90 91
          "Number of completed buffers that triggers log processing.")      \
                                                                            \
92 93 94 95 96 97 98
  product(uintx, G1SATBBufferEnqueueingThresholdPercent, 60,                \
          "Before enqueueing them, each mutator thread tries to do some "   \
          "filtering on the SATB buffers it generates. If post-filtering "  \
          "the percentage of retained entries is over this threshold "      \
          "the buffer will be enqueued for processing. A value of 0 "       \
          "specifies that mutator threads should not do such filtering.")   \
                                                                            \
99 100 101 102 103 104 105 106
  develop(intx, G1ExtraRegionSurvRate, 33,                                  \
          "If the young survival rate is S, and there's room left in "      \
          "to-space, we will allow regions whose survival rate is up to "   \
          "S + (1 - S)*X, where X is this parameter (as a fraction.)")      \
                                                                            \
  develop(bool, G1SATBPrintStubs, false,                                    \
          "If true, print generated stubs for the SATB barrier")            \
                                                                            \
107
  experimental(intx, G1ExpandByPercentOfAvailable, 20,                      \
108 109 110 111 112 113 114 115
          "When expanding, % of uncommitted space to claim.")               \
                                                                            \
  develop(bool, G1RSBarrierRegionFilter, true,                              \
          "If true, generate region filtering code in RS barrier")          \
                                                                            \
  develop(bool, G1RSBarrierNullFilter, true,                                \
          "If true, generate null-pointer filtering code in RS barrier")    \
                                                                            \
116 117 118
  develop(bool, G1DeferredRSUpdate, true,                                   \
          "If true, use deferred RS updates")                               \
                                                                            \
119 120 121 122 123 124 125
  develop(bool, G1RSLogCheckCardTable, false,                               \
          "If true, verify that no dirty cards remain after RS log "        \
          "processing.")                                                    \
                                                                            \
  develop(bool, G1RSCountHisto, false,                                      \
          "If true, print a histogram of RS occupancies after each pause")  \
                                                                            \
126 127 128
  diagnostic(bool, G1PrintRegionLivenessInfo, false,                        \
            "Prints the liveness information for all regions in the heap "  \
            "at the end of a marking cycle.")                               \
129
                                                                            \
130 131 132
  product(intx, G1UpdateBufferSize, 256,                                    \
          "Size of an update buffer")                                       \
                                                                            \
133
  product(intx, G1ConcRefinementYellowZone, 0,                              \
134
          "Number of enqueued update buffers that will "                    \
135 136
          "trigger concurrent processing. Will be selected ergonomically "  \
          "by default.")                                                    \
137
                                                                            \
138
  product(intx, G1ConcRefinementRedZone, 0,                                 \
139
          "Maximum number of enqueued update buffers before mutator "       \
140 141 142 143
          "threads start processing new ones instead of enqueueing them. "  \
          "Will be selected ergonomically by default. Zero will disable "   \
          "concurrent processing.")                                         \
                                                                            \
144
  product(intx, G1ConcRefinementGreenZone, 0,                               \
145 146 147 148
          "The number of update buffers that are left in the queue by the " \
          "concurrent processing threads. Will be selected ergonomically "  \
          "by default.")                                                    \
                                                                            \
149
  product(intx, G1ConcRefinementServiceIntervalMillis, 300,                 \
150 151 152
          "The last concurrent refinement thread wakes up every "           \
          "specified number of milliseconds to do miscellaneous work.")     \
                                                                            \
153
  product(intx, G1ConcRefinementThresholdStep, 0,                           \
154 155 156 157
          "Each time the rset update queue increases by this amount "       \
          "activate the next refinement thread if available. "              \
          "Will be selected ergonomically by default.")                     \
                                                                            \
158
  product(intx, G1RSetUpdatingPauseTimePercent, 10,                         \
159 160 161
          "A target percentage of time that is allowed to be spend on "     \
          "process RS update buffers during the collection pause.")         \
                                                                            \
162
  product(bool, G1UseAdaptiveConcRefinement, true,                          \
163 164
          "Select green, yellow and red zones adaptively to meet the "      \
          "the pause requirements.")                                        \
165
                                                                            \
166
  product(uintx, G1ConcRSLogCacheSize, 10,                                  \
167 168
          "Log base 2 of the length of conc RS hot-card cache.")            \
                                                                            \
169
  product(uintx, G1ConcRSHotCardLimit, 4,                                   \
170 171 172 173 174
          "The threshold that defines (>=) a hot card.")                    \
                                                                            \
  develop(bool, G1PrintOopAppls, false,                                     \
          "When true, print applications of closures to external locs.")    \
                                                                            \
175 176 177 178 179 180 181 182 183 184 185 186 187 188
  develop(intx, G1RSetRegionEntriesBase, 256,                               \
          "Max number of regions in a fine-grain table per MB.")            \
                                                                            \
  product(intx, G1RSetRegionEntries, 0,                                     \
          "Max number of regions for which we keep bitmaps."                \
          "Will be set ergonomically by default")                           \
                                                                            \
  develop(intx, G1RSetSparseRegionEntriesBase, 4,                           \
          "Max number of entries per region in a sparse table "             \
          "per MB.")                                                        \
                                                                            \
  product(intx, G1RSetSparseRegionEntries, 0,                               \
          "Max number of entries per region in a sparse table."             \
          "Will be set ergonomically by default.")                          \
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
                                                                            \
  develop(bool, G1RecordHRRSOops, false,                                    \
          "When true, record recent calls to rem set operations.")          \
                                                                            \
  develop(bool, G1RecordHRRSEvents, false,                                  \
          "When true, record recent calls to rem set operations.")          \
                                                                            \
  develop(intx, G1MaxVerifyFailures, -1,                                    \
          "The maximum number of verification failrues to print.  "         \
          "-1 means print all.")                                            \
                                                                            \
  develop(bool, G1ScrubRemSets, true,                                       \
          "When true, do RS scrubbing after cleanup.")                      \
                                                                            \
  develop(bool, G1RSScrubVerbose, false,                                    \
          "When true, do RS scrubbing with verbose output.")                \
                                                                            \
  develop(bool, G1YoungSurvRateVerbose, false,                              \
          "print out the survival rate of young regions according to age.") \
                                                                            \
  develop(intx, G1YoungSurvRateNumRegionsSummary, 0,                        \
          "the number of regions for which we'll print a surv rate "        \
          "summary.")                                                       \
                                                                            \
213
  product(uintx, G1ReservePercent, 10,                                      \
214 215 216
          "It determines the minimum reserve we should have in the heap "   \
          "to minimize the probability of promotion failure.")              \
                                                                            \
217
  diagnostic(bool, G1PrintHeapRegions, false,                               \
218 219 220 221 222 223 224 225 226
          "If set G1 will print information on which regions are being "    \
          "allocated and which are reclaimed.")                             \
                                                                            \
  develop(bool, G1HRRSUseSparseTable, true,                                 \
          "When true, use sparse table to save space.")                     \
                                                                            \
  develop(bool, G1HRRSFlushLogBuffersOnVerify, false,                       \
          "Forces flushing of log buffers before verification.")            \
                                                                            \
227 228 229 230
  develop(bool, G1FailOnFPError, false,                                     \
          "When set, G1 will fail when it encounters an FP 'error', "       \
          "so as to allow debugging")                                       \
                                                                            \
231 232 233
  product(uintx, G1HeapRegionSize, 0,                                       \
          "Size of the G1 regions.")                                        \
                                                                            \
234
  experimental(bool, G1UseParallelRSetUpdating, true,                       \
235 236 237
          "Enables the parallelization of remembered set updating "         \
          "during evacuation pauses")                                       \
                                                                            \
238
  experimental(bool, G1UseParallelRSetScanning, true,                       \
239
          "Enables the parallelization of remembered set scanning "         \
240 241
          "during evacuation pauses")                                       \
                                                                            \
242
  product(uintx, G1ConcRefinementThreads, 0,                                \
243
          "If non-0 is the number of parallel rem set update threads, "     \
244 245
          "otherwise the value is determined ergonomically.")               \
                                                                            \
246
  develop(bool, G1VerifyCTCleanup, false,                                   \
247 248
          "Verify card table cleanup.")                                     \
                                                                            \
249 250 251 252
  product(uintx, G1RSetScanBlockSize, 64,                                   \
          "Size of a work unit of cards claimed by a worker thread"         \
          "during RSet scanning.")                                          \
                                                                            \
253 254 255 256 257 258 259 260 261 262 263 264 265
  develop(uintx, G1SecondaryFreeListAppendLength, 5,                        \
          "The number of regions we will add to the secondary free list "   \
          "at every append operation")                                      \
                                                                            \
  develop(bool, G1ConcRegionFreeingVerbose, false,                          \
          "Enables verboseness during concurrent region freeing")           \
                                                                            \
  develop(bool, G1StressConcRegionFreeing, false,                           \
          "It stresses the concurrent region freeing operation")            \
                                                                            \
  develop(uintx, G1StressConcRegionFreeingDelayMillis, 0,                   \
          "Artificial delay during concurrent region freeing")              \
                                                                            \
266 267 268 269 270
  develop(uintx, G1DummyRegionsPerGC, 0,                                    \
          "The number of dummy regions G1 will allocate at the end of "     \
          "each evacuation pause in order to artificially fill up the "     \
          "heap and stress the marking implementation.")                    \
                                                                            \
271 272
  develop(bool, G1ExitOnExpansionFailure, false,                            \
          "Raise a fatal VM exit out of memory failure in the event "       \
273 274 275 276
          " that heap expansion fails due to running out of swap.")         \
                                                                            \
  develop(uintx, G1ConcMarkForceOverflow, 0,                                \
          "The number of times we'll force an overflow during "             \
277 278
          "concurrent marking")                                             \
                                                                            \
279
  experimental(uintx, G1NewSizePercent, 5,                                  \
280 281 282
          "Percentage (0-100) of the heap size to use as default "          \
          "minimum young gen size.")                                        \
                                                                            \
283
  experimental(uintx, G1MaxNewSizePercent, 60,                              \
284 285 286
          "Percentage (0-100) of the heap size to use as default "          \
          " maximum young gen size.")                                       \
                                                                            \
287
  experimental(uintx, G1MixedGCLiveThresholdPercent, 65,                    \
288 289 290
          "Threshold for regions to be considered for inclusion in the "    \
          "collection set of mixed GCs. "                                   \
          "Regions with live bytes exceeding this will not be collected.")  \
291
                                                                            \
292
  product(uintx, G1HeapWastePercent, 10,                                    \
293 294
          "Amount of space, expressed as a percentage of the heap size, "   \
          "that G1 is willing not to collect to avoid expensive GCs.")      \
295
                                                                            \
296
  product(uintx, G1MixedGCCountTarget, 8,                                   \
297
          "The target number of mixed GCs after a marking cycle.")          \
298
                                                                            \
299
  experimental(uintx, G1OldCSetRegionThresholdPercent, 10,                  \
300
          "An upper bound for the number of old CSet regions expressed "    \
301 302 303
          "as a percentage of the heap size.")                              \
                                                                            \
  experimental(ccstr, G1LogLevel, NULL,                                     \
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
          "Log level for G1 logging: fine, finer, finest")                  \
                                                                            \
  notproduct(bool, G1EvacuationFailureALot, false,                          \
          "Force use of evacuation failure handling during certain "        \
          "evacuation pauses")                                              \
                                                                            \
  develop(uintx, G1EvacuationFailureALotCount, 1000,                        \
          "Number of successful evacuations between evacuation failures "   \
          "occurring at object copying")                                    \
                                                                            \
  develop(uintx, G1EvacuationFailureALotInterval, 5,                        \
          "Total collections between forced triggering of evacuation "      \
          "failures")                                                       \
                                                                            \
  develop(bool, G1EvacuationFailureALotDuringConcMark, true,                \
          "Force use of evacuation failure handling during evacuation "     \
          "pauses when marking is in progress")                             \
                                                                            \
  develop(bool, G1EvacuationFailureALotDuringInitialMark, true,             \
          "Force use of evacuation failure handling during initial mark "   \
          "evacuation pauses")                                              \
                                                                            \
  develop(bool, G1EvacuationFailureALotDuringYoungGC, true,                 \
          "Force use of evacuation failure handling during young "          \
          "evacuation pauses")                                              \
                                                                            \
  develop(bool, G1EvacuationFailureALotDuringMixedGC, true,                 \
          "Force use of evacuation failure handling during mixed "          \
          "evacuation pauses")
333

334
G1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG)
335 336

#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1_GLOBALS_HPP