Print this page
| Split |
Split |
Close |
| Expand all |
| Collapse all |
--- old/src/share/vm/gc/g1/g1_globals.hpp
+++ new/src/share/vm/gc/g1/g1_globals.hpp
1 1 /*
2 2 * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation.
8 8 *
9 9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 12 * version 2 for more details (a copy is included in the LICENSE file that
13 13 * accompanied this code).
14 14 *
15 15 * You should have received a copy of the GNU General Public License version
16 16 * 2 along with this work; if not, write to the Free Software Foundation,
17 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 18 *
19 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 20 * or visit www.oracle.com if you need additional information or have any
21 21 * questions.
22 22 *
23 23 */
24 24
25 25 #ifndef SHARE_VM_GC_G1_G1_GLOBALS_HPP
26 26 #define SHARE_VM_GC_G1_G1_GLOBALS_HPP
27 27
28 28 #include "runtime/globals.hpp"
29 29 #include <float.h> // for DBL_MAX
30 30 //
31 31 // Defines all globals flags used by the garbage-first compiler.
32 32 //
33 33
34 34 #define G1_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, range, constraint) \
35 35 \
36 36 product(bool, G1UseAdaptiveIHOP, false, \
37 37 "Adaptively adjust InitiatingHeapOccupancyPercent from the " \
38 38 "initial value.") \
39 39 \
40 40 experimental(size_t, G1AdaptiveIHOPNumInitialSamples, 3, \
41 41 "How many completed time periods from initial mark to first " \
42 42 "mixed gc are required to use the input values for prediction " \
43 43 "of the optimal occupancy to start marking.") \
44 44 range(1, max_intx) \
45 45 \
46 46 product(uintx, G1ConfidencePercent, 50, \
47 47 "Confidence level for MMU/pause predictions") \
48 48 range(0, 100) \
49 49 \
50 50 develop(intx, G1MarkingOverheadPercent, 0, \
51 51 "Overhead of concurrent marking") \
52 52 range(0, 100) \
53 53 \
54 54 develop(intx, G1MarkingVerboseLevel, 0, \
55 55 "Level (0-4) of verboseness of the marking code") \
56 56 range(0, 4) \
57 57 \
58 58 develop(bool, G1TraceMarkStackOverflow, false, \
59 59 "If true, extra debugging code for CM restart for ovflw.") \
60 60 \
61 61 diagnostic(bool, G1SummarizeConcMark, false, \
62 62 "Summarize concurrent mark info") \
63 63 \
64 64 diagnostic(bool, G1SummarizeRSetStats, false, \
65 65 "Summarize remembered set processing info") \
66 66 \
67 67 diagnostic(intx, G1SummarizeRSetStatsPeriod, 0, \
68 68 "The period (in number of GCs) at which we will generate " \
69 69 "update buffer processing info " \
70 70 "(0 means do not periodically generate this info); " \
71 71 "it also requires -XX:+G1SummarizeRSetStats") \
72 72 range(0, max_intx) \
73 73 \
74 74 diagnostic(bool, G1TraceConcRefinement, false, \
75 75 "Trace G1 concurrent refinement") \
76 76 \
77 77 experimental(bool, G1TraceStringSymbolTableScrubbing, false, \
78 78 "Trace information string and symbol table scrubbing.") \
79 79 \
80 80 product(double, G1ConcMarkStepDurationMillis, 10.0, \
81 81 "Target duration of individual concurrent marking steps " \
82 82 "in milliseconds.") \
83 83 range(1.0, DBL_MAX) \
84 84 \
85 85 product(intx, G1RefProcDrainInterval, 10, \
86 86 "The number of discovered reference objects to process before " \
87 87 "draining concurrent marking work queues.") \
88 88 range(1, max_intx) \
89 89 \
90 90 experimental(bool, G1UseConcMarkReferenceProcessing, true, \
91 91 "If true, enable reference discovery during concurrent " \
92 92 "marking and reference processing at the end of remark.") \
93 93 \
94 94 experimental(double, G1LastPLABAverageOccupancy, 50.0, \
95 95 "The expected average occupancy of the last PLAB in " \
96 96 "percent.") \
97 97 range(0.001, 100.0) \
98 98 \
99 99 product(size_t, G1SATBBufferSize, 1*K, \
100 100 "Number of entries in an SATB log buffer.") \
101 101 range(1, max_uintx) \
102 102 \
103 103 develop(intx, G1SATBProcessCompletedThreshold, 20, \
104 104 "Number of completed buffers that triggers log processing.") \
105 105 range(0, max_jint) \
106 106 \
107 107 product(uintx, G1SATBBufferEnqueueingThresholdPercent, 60, \
108 108 "Before enqueueing them, each mutator thread tries to do some " \
109 109 "filtering on the SATB buffers it generates. If post-filtering " \
110 110 "the percentage of retained entries is over this threshold " \
111 111 "the buffer will be enqueued for processing. A value of 0 " \
112 112 "specifies that mutator threads should not do such filtering.") \
113 113 range(0, 100) \
114 114 \
115 115 experimental(intx, G1ExpandByPercentOfAvailable, 20, \
116 116 "When expanding, % of uncommitted space to claim.") \
117 117 range(0, 100) \
118 118 \
119 119 develop(bool, G1RSBarrierRegionFilter, true, \
120 120 "If true, generate region filtering code in RS barrier") \
121 121 \
122 122 diagnostic(bool, G1PrintRegionLivenessInfo, false, \
123 123 "Prints the liveness information for all regions in the heap " \
124 124 "at the end of a marking cycle.") \
125 125 \
126 126 product(size_t, G1UpdateBufferSize, 256, \
127 127 "Size of an update buffer") \
128 128 range(1, NOT_LP64(32*M) LP64_ONLY(1*G)) \
129 129 \
130 130 product(intx, G1ConcRefinementYellowZone, 0, \
131 131 "Number of enqueued update buffers that will " \
132 132 "trigger concurrent processing. Will be selected ergonomically " \
133 133 "by default.") \
134 134 range(0, max_intx) \
135 135 \
136 136 product(intx, G1ConcRefinementRedZone, 0, \
137 137 "Maximum number of enqueued update buffers before mutator " \
138 138 "threads start processing new ones instead of enqueueing them. " \
139 139 "Will be selected ergonomically by default. Zero will disable " \
140 140 "concurrent processing.") \
141 141 range(0, max_intx) \
142 142 \
143 143 product(intx, G1ConcRefinementGreenZone, 0, \
144 144 "The number of update buffers that are left in the queue by the " \
145 145 "concurrent processing threads. Will be selected ergonomically " \
146 146 "by default.") \
147 147 range(0, max_intx) \
148 148 \
149 149 product(intx, G1ConcRefinementServiceIntervalMillis, 300, \
150 150 "The last concurrent refinement thread wakes up every " \
151 151 "specified number of milliseconds to do miscellaneous work.") \
152 152 range(0, max_jint) \
153 153 \
154 154 product(intx, G1ConcRefinementThresholdStep, 0, \
155 155 "Each time the rset update queue increases by this amount " \
156 156 "activate the next refinement thread if available. " \
157 157 "Will be selected ergonomically by default.") \
158 158 \
159 159 product(intx, G1RSetUpdatingPauseTimePercent, 10, \
160 160 "A target percentage of time that is allowed to be spend on " \
161 161 "process RS update buffers during the collection pause.") \
162 162 range(0, 100) \
163 163 \
164 164 product(bool, G1UseAdaptiveConcRefinement, true, \
165 165 "Select green, yellow and red zones adaptively to meet the " \
166 166 "the pause requirements.") \
167 167 \
168 168 product(size_t, G1ConcRSLogCacheSize, 10, \
169 169 "Log base 2 of the length of conc RS hot-card cache.") \
170 170 range(0, 27) \
171 171 \
172 172 product(uintx, G1ConcRSHotCardLimit, 4, \
173 173 "The threshold that defines (>=) a hot card.") \
174 174 range(0, max_jubyte) \
175 175 \
176 176 develop(intx, G1RSetRegionEntriesBase, 256, \
177 177 "Max number of regions in a fine-grain table per MB.") \
178 178 range(1, max_jint/wordSize) \
179 179 \
180 180 product(intx, G1RSetRegionEntries, 0, \
181 181 "Max number of regions for which we keep bitmaps." \
182 182 "Will be set ergonomically by default") \
183 183 range(0, max_jint/wordSize) \
184 184 constraint(G1RSetRegionEntriesConstraintFunc,AfterErgo) \
185 185 \
186 186 develop(intx, G1RSetSparseRegionEntriesBase, 4, \
187 187 "Max number of entries per region in a sparse table " \
188 188 "per MB.") \
189 189 range(1, max_jint/wordSize) \
190 190 \
191 191 product(intx, G1RSetSparseRegionEntries, 0, \
192 192 "Max number of entries per region in a sparse table." \
193 193 "Will be set ergonomically by default.") \
194 194 range(0, max_jint/wordSize) \
195 195 constraint(G1RSetSparseRegionEntriesConstraintFunc,AfterErgo) \
196 196 \
197 197 develop(intx, G1MaxVerifyFailures, -1, \
198 198 "The maximum number of verification failures to print. " \
199 199 "-1 means print all.") \
200 200 range(-1, max_jint) \
201 201 \
202 202 develop(bool, G1ScrubRemSets, true, \
203 203 "When true, do RS scrubbing after cleanup.") \
204 204 \
205 205 develop(bool, G1RSScrubVerbose, false, \
206 206 "When true, do RS scrubbing with verbose output.") \
207 207 \
208 208 develop(bool, G1YoungSurvRateVerbose, false, \
209 209 "print out the survival rate of young regions according to age.") \
210 210 \
211 211 develop(intx, G1YoungSurvRateNumRegionsSummary, 0, \
212 212 "the number of regions for which we'll print a surv rate " \
213 213 "summary.") \
214 214 range(0, max_intx) \
215 215 constraint(G1YoungSurvRateNumRegionsSummaryConstraintFunc,AfterErgo)\
216 216 \
217 217 product(uintx, G1ReservePercent, 10, \
218 218 "It determines the minimum reserve we should have in the heap " \
219 219 "to minimize the probability of promotion failure.") \
220 220 range(0, 50) \
221 221 \
222 222 diagnostic(bool, G1PrintHeapRegions, false, \
223 223 "If set G1 will print information on which regions are being " \
224 224 "allocated and which are reclaimed.") \
225 225 \
226 226 develop(bool, G1HRRSUseSparseTable, true, \
227 227 "When true, use sparse table to save space.") \
228 228 \
229 229 develop(bool, G1HRRSFlushLogBuffersOnVerify, false, \
230 230 "Forces flushing of log buffers before verification.") \
231 231 \
232 232 product(size_t, G1HeapRegionSize, 0, \
233 233 "Size of the G1 regions.") \
234 234 range(0, 32*M) \
235 235 constraint(G1HeapRegionSizeConstraintFunc,AfterMemoryInit) \
236 236 \
237 237 product(uintx, G1ConcRefinementThreads, 0, \
238 238 "If non-0 is the number of parallel rem set update threads, " \
239 239 "otherwise the value is determined ergonomically.") \
240 240 range(0, (max_jint-1)/wordSize) \
241 241 \
242 242 develop(bool, G1VerifyCTCleanup, false, \
243 243 "Verify card table cleanup.") \
244 244 \
245 245 product(size_t, G1RSetScanBlockSize, 64, \
246 246 "Size of a work unit of cards claimed by a worker thread" \
247 247 "during RSet scanning.") \
248 248 range(1, max_uintx) \
249 249 \
250 250 develop(uintx, G1SecondaryFreeListAppendLength, 5, \
251 251 "The number of regions we will add to the secondary free list " \
252 252 "at every append operation") \
253 253 \
254 254 develop(bool, G1ConcRegionFreeingVerbose, false, \
255 255 "Enables verboseness during concurrent region freeing") \
256 256 \
257 257 develop(bool, G1StressConcRegionFreeing, false, \
258 258 "It stresses the concurrent region freeing operation") \
259 259 \
260 260 develop(uintx, G1StressConcRegionFreeingDelayMillis, 0, \
261 261 "Artificial delay during concurrent region freeing") \
262 262 \
263 263 develop(uintx, G1DummyRegionsPerGC, 0, \
264 264 "The number of dummy regions G1 will allocate at the end of " \
265 265 "each evacuation pause in order to artificially fill up the " \
266 266 "heap and stress the marking implementation.") \
267 267 \
268 268 develop(bool, G1ExitOnExpansionFailure, false, \
269 269 "Raise a fatal VM exit out of memory failure in the event " \
270 270 " that heap expansion fails due to running out of swap.") \
271 271 \
272 272 develop(uintx, G1ConcMarkForceOverflow, 0, \
273 273 "The number of times we'll force an overflow during " \
274 274 "concurrent marking") \
275 275 \
276 276 experimental(uintx, G1MaxNewSizePercent, 60, \
277 277 "Percentage (0-100) of the heap size to use as default " \
278 278 " maximum young gen size.") \
279 279 range(0, 100) \
280 280 constraint(G1MaxNewSizePercentConstraintFunc,AfterErgo) \
281 281 \
282 282 experimental(uintx, G1NewSizePercent, 5, \
283 283 "Percentage (0-100) of the heap size to use as default " \
284 284 "minimum young gen size.") \
285 285 range(0, 100) \
286 286 constraint(G1NewSizePercentConstraintFunc,AfterErgo) \
287 287 \
288 288 experimental(uintx, G1MixedGCLiveThresholdPercent, 85, \
289 289 "Threshold for regions to be considered for inclusion in the " \
290 290 "collection set of mixed GCs. " \
291 291 "Regions with live bytes exceeding this will not be collected.") \
292 292 range(0, 100) \
293 293 \
294 294 product(uintx, G1HeapWastePercent, 5, \
295 295 "Amount of space, expressed as a percentage of the heap size, " \
296 296 "that G1 is willing not to collect to avoid expensive GCs.") \
297 297 range(0, 100) \
298 298 \
299 299 product(uintx, G1MixedGCCountTarget, 8, \
300 300 "The target number of mixed GCs after a marking cycle.") \
301 301 \
302 302 experimental(bool, G1EagerReclaimHumongousObjects, true, \
303 303 "Try to reclaim dead large objects at every young GC.") \
304 304 \
305 305 experimental(bool, G1EagerReclaimHumongousObjectsWithStaleRefs, true, \
306 306 "Try to reclaim dead large objects that have a few stale " \
307 307 "references at every young GC.") \
308 308 \
309 309 experimental(bool, G1TraceEagerReclaimHumongousObjects, false, \
310 310 "Print some information about large object liveness " \
311 311 "at every young GC.") \
312 312 \
313 313 experimental(uintx, G1OldCSetRegionThresholdPercent, 10, \
314 314 "An upper bound for the number of old CSet regions expressed " \
315 315 "as a percentage of the heap size.") \
316 316 range(0, 100) \
317 317 \
318 318 experimental(ccstr, G1LogLevel, NULL, \
319 319 "Log level for G1 logging: fine, finer, finest") \
320 320 \
321 321 notproduct(bool, G1EvacuationFailureALot, false, \
322 322 "Force use of evacuation failure handling during certain " \
323 323 "evacuation pauses") \
324 324 \
325 325 develop(uintx, G1EvacuationFailureALotCount, 1000, \
326 326 "Number of successful evacuations between evacuation failures " \
327 327 "occurring at object copying") \
328 328 \
329 329 develop(uintx, G1EvacuationFailureALotInterval, 5, \
330 330 "Total collections between forced triggering of evacuation " \
331 331 "failures") \
332 332 \
333 333 develop(bool, G1EvacuationFailureALotDuringConcMark, true, \
334 334 "Force use of evacuation failure handling during evacuation " \
335 335 "pauses when marking is in progress") \
336 336 \
337 337 develop(bool, G1EvacuationFailureALotDuringInitialMark, true, \
338 338 "Force use of evacuation failure handling during initial mark " \
339 339 "evacuation pauses") \
340 340 \
341 341 develop(bool, G1EvacuationFailureALotDuringYoungGC, true, \
|
↓ open down ↓ |
341 lines elided |
↑ open up ↑ |
342 342 "Force use of evacuation failure handling during young " \
343 343 "evacuation pauses") \
344 344 \
345 345 develop(bool, G1EvacuationFailureALotDuringMixedGC, true, \
346 346 "Force use of evacuation failure handling during mixed " \
347 347 "evacuation pauses") \
348 348 \
349 349 diagnostic(bool, G1VerifyRSetsDuringFullGC, false, \
350 350 "If true, perform verification of each heap region's " \
351 351 "remembered set when verifying the heap during a full GC.") \
352 + diagnostic(bool, G1VerifyRSetsAfterEvacuationPause, false, \
353 + "If true, perform verification of each heap region's " \
354 + "remembered set after evacuation pause.") \
352 355 \
353 356 diagnostic(bool, G1VerifyHeapRegionCodeRoots, false, \
354 357 "Verify the code root lists attached to each heap region.") \
355 358 \
356 359 develop(bool, G1VerifyBitmaps, false, \
357 360 "Verifies the consistency of the marking bitmaps")
358 361
359 362 G1_FLAGS(DECLARE_DEVELOPER_FLAG, \
360 363 DECLARE_PD_DEVELOPER_FLAG, \
361 364 DECLARE_PRODUCT_FLAG, \
362 365 DECLARE_PD_PRODUCT_FLAG, \
363 366 DECLARE_DIAGNOSTIC_FLAG, \
364 367 DECLARE_EXPERIMENTAL_FLAG, \
365 368 DECLARE_NOTPRODUCT_FLAG, \
366 369 DECLARE_MANAGEABLE_FLAG, \
367 370 DECLARE_PRODUCT_RW_FLAG, \
368 371 IGNORE_RANGE, \
369 372 IGNORE_CONSTRAINT)
370 373
371 374 #endif // SHARE_VM_GC_G1_G1_GLOBALS_HPP
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX