1 /* |
|
2 * Copyright (c) 1997, 2018, 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 * |
|
23 */ |
|
24 |
|
25 #ifndef SHARE_GC_CMS_CMS_GLOBALS_HPP |
|
26 #define SHARE_GC_CMS_CMS_GLOBALS_HPP |
|
27 |
|
28 #define GC_CMS_FLAGS(develop, \ |
|
29 develop_pd, \ |
|
30 product, \ |
|
31 product_pd, \ |
|
32 diagnostic, \ |
|
33 diagnostic_pd, \ |
|
34 experimental, \ |
|
35 notproduct, \ |
|
36 manageable, \ |
|
37 product_rw, \ |
|
38 lp64_product, \ |
|
39 range, \ |
|
40 constraint, \ |
|
41 writeable) \ |
|
42 product(bool, UseCMSBestFit, true, \ |
|
43 "Use CMS best fit allocation strategy") \ |
|
44 \ |
|
45 product(size_t, CMSOldPLABMax, 1024, \ |
|
46 "Maximum size of CMS gen promotion LAB caches per worker " \ |
|
47 "per block size") \ |
|
48 range(1, max_uintx) \ |
|
49 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \ |
|
50 \ |
|
51 product(size_t, CMSOldPLABMin, 16, \ |
|
52 "Minimum size of CMS gen promotion LAB caches per worker " \ |
|
53 "per block size") \ |
|
54 range(1, max_uintx) \ |
|
55 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \ |
|
56 \ |
|
57 product(uintx, CMSOldPLABNumRefills, 4, \ |
|
58 "Nominal number of refills of CMS gen promotion LAB cache " \ |
|
59 "per worker per block size") \ |
|
60 range(1, max_uintx) \ |
|
61 \ |
|
62 product(bool, CMSOldPLABResizeQuicker, false, \ |
|
63 "React on-the-fly during a scavenge to a sudden " \ |
|
64 "change in block demand rate") \ |
|
65 \ |
|
66 product(uintx, CMSOldPLABToleranceFactor, 4, \ |
|
67 "The tolerance of the phase-change detector for on-the-fly " \ |
|
68 "PLAB resizing during a scavenge") \ |
|
69 range(1, max_uintx) \ |
|
70 \ |
|
71 product(uintx, CMSOldPLABReactivityFactor, 2, \ |
|
72 "The gain in the feedback loop for on-the-fly PLAB resizing " \ |
|
73 "during a scavenge") \ |
|
74 range(1, max_uintx) \ |
|
75 \ |
|
76 product_pd(size_t, CMSYoungGenPerWorker, \ |
|
77 "The maximum size of young gen chosen by default per GC worker " \ |
|
78 "thread available") \ |
|
79 range(1, max_uintx) \ |
|
80 \ |
|
81 product(uintx, CMSIncrementalSafetyFactor, 10, \ |
|
82 "Percentage (0-100) used to add conservatism when computing the " \ |
|
83 "duty cycle") \ |
|
84 range(0, 100) \ |
|
85 \ |
|
86 product(uintx, CMSExpAvgFactor, 50, \ |
|
87 "Percentage (0-100) used to weight the current sample when " \ |
|
88 "computing exponential averages for CMS statistics") \ |
|
89 range(0, 100) \ |
|
90 \ |
|
91 product(uintx, CMS_FLSWeight, 75, \ |
|
92 "Percentage (0-100) used to weight the current sample when " \ |
|
93 "computing exponentially decaying averages for CMS FLS " \ |
|
94 "statistics") \ |
|
95 range(0, 100) \ |
|
96 \ |
|
97 product(uintx, CMS_FLSPadding, 1, \ |
|
98 "The multiple of deviation from mean to use for buffering " \ |
|
99 "against volatility in free list demand") \ |
|
100 range(0, max_juint) \ |
|
101 \ |
|
102 product(uintx, FLSCoalescePolicy, 2, \ |
|
103 "CMS: aggressiveness level for coalescing, increasing " \ |
|
104 "from 0 to 4") \ |
|
105 range(0, 4) \ |
|
106 \ |
|
107 product(bool, FLSAlwaysCoalesceLarge, false, \ |
|
108 "CMS: larger free blocks are always available for coalescing") \ |
|
109 \ |
|
110 product(double, FLSLargestBlockCoalesceProximity, 0.99, \ |
|
111 "CMS: the smaller the percentage the greater the coalescing " \ |
|
112 "force") \ |
|
113 range(0.0, 1.0) \ |
|
114 \ |
|
115 product(double, CMSSmallCoalSurplusPercent, 1.05, \ |
|
116 "CMS: the factor by which to inflate estimated demand of small " \ |
|
117 "block sizes to prevent coalescing with an adjoining block") \ |
|
118 range(0.0, DBL_MAX) \ |
|
119 \ |
|
120 product(double, CMSLargeCoalSurplusPercent, 0.95, \ |
|
121 "CMS: the factor by which to inflate estimated demand of large " \ |
|
122 "block sizes to prevent coalescing with an adjoining block") \ |
|
123 range(0.0, DBL_MAX) \ |
|
124 \ |
|
125 product(double, CMSSmallSplitSurplusPercent, 1.10, \ |
|
126 "CMS: the factor by which to inflate estimated demand of small " \ |
|
127 "block sizes to prevent splitting to supply demand for smaller " \ |
|
128 "blocks") \ |
|
129 range(0.0, DBL_MAX) \ |
|
130 \ |
|
131 product(double, CMSLargeSplitSurplusPercent, 1.00, \ |
|
132 "CMS: the factor by which to inflate estimated demand of large " \ |
|
133 "block sizes to prevent splitting to supply demand for smaller " \ |
|
134 "blocks") \ |
|
135 range(0.0, DBL_MAX) \ |
|
136 \ |
|
137 product(bool, CMSExtrapolateSweep, false, \ |
|
138 "CMS: cushion for block demand during sweep") \ |
|
139 \ |
|
140 product(uintx, CMS_SweepWeight, 75, \ |
|
141 "Percentage (0-100) used to weight the current sample when " \ |
|
142 "computing exponentially decaying average for inter-sweep " \ |
|
143 "duration") \ |
|
144 range(0, 100) \ |
|
145 \ |
|
146 product(uintx, CMS_SweepPadding, 1, \ |
|
147 "The multiple of deviation from mean to use for buffering " \ |
|
148 "against volatility in inter-sweep duration") \ |
|
149 range(0, max_juint) \ |
|
150 \ |
|
151 product(uintx, CMS_SweepTimerThresholdMillis, 10, \ |
|
152 "Skip block flux-rate sampling for an epoch unless inter-sweep " \ |
|
153 "duration exceeds this threshold in milliseconds") \ |
|
154 range(0, max_uintx) \ |
|
155 \ |
|
156 product(bool, CMSClassUnloadingEnabled, true, \ |
|
157 "Whether class unloading enabled when using CMS GC") \ |
|
158 \ |
|
159 product(uintx, CMSClassUnloadingMaxInterval, 0, \ |
|
160 "When CMS class unloading is enabled, the maximum CMS cycle " \ |
|
161 "count for which classes may not be unloaded") \ |
|
162 range(0, max_uintx) \ |
|
163 \ |
|
164 product(uintx, CMSIndexedFreeListReplenish, 4, \ |
|
165 "Replenish an indexed free list with this number of chunks") \ |
|
166 range(1, max_uintx) \ |
|
167 \ |
|
168 product(bool, CMSReplenishIntermediate, true, \ |
|
169 "Replenish all intermediate free-list caches") \ |
|
170 \ |
|
171 product(bool, CMSSplitIndexedFreeListBlocks, true, \ |
|
172 "When satisfying batched demand, split blocks from the " \ |
|
173 "IndexedFreeList whose size is a multiple of requested size") \ |
|
174 \ |
|
175 product(bool, CMSLoopWarn, false, \ |
|
176 "Warn in case of excessive CMS looping") \ |
|
177 \ |
|
178 notproduct(bool, CMSMarkStackOverflowALot, false, \ |
|
179 "Simulate frequent marking stack / work queue overflow") \ |
|
180 \ |
|
181 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \ |
|
182 "An \"interval\" counter that determines how frequently " \ |
|
183 "to simulate overflow; a smaller number increases frequency") \ |
|
184 \ |
|
185 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \ |
|
186 "Maximum number of abortable preclean iterations, if > 0") \ |
|
187 range(0, max_uintx) \ |
|
188 \ |
|
189 product(intx, CMSMaxAbortablePrecleanTime, 5000, \ |
|
190 "Maximum time in abortable preclean (in milliseconds)") \ |
|
191 range(0, max_intx) \ |
|
192 \ |
|
193 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \ |
|
194 "Nominal minimum work per abortable preclean iteration") \ |
|
195 range(0, max_uintx) \ |
|
196 \ |
|
197 manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \ |
|
198 "Time that we sleep between iterations when not given " \ |
|
199 "enough work per iteration") \ |
|
200 range(0, max_intx) \ |
|
201 \ |
|
202 /* 4096 = CardTable::card_size_in_words * BitsPerWord */ \ |
|
203 product(size_t, CMSRescanMultiple, 32, \ |
|
204 "Size (in cards) of CMS parallel rescan task") \ |
|
205 range(1, SIZE_MAX / 4096) \ |
|
206 constraint(CMSRescanMultipleConstraintFunc,AfterMemoryInit) \ |
|
207 \ |
|
208 /* 4096 = CardTable::card_size_in_words * BitsPerWord */ \ |
|
209 product(size_t, CMSConcMarkMultiple, 32, \ |
|
210 "Size (in cards) of CMS concurrent MT marking task") \ |
|
211 range(1, SIZE_MAX / 4096) \ |
|
212 constraint(CMSConcMarkMultipleConstraintFunc,AfterMemoryInit) \ |
|
213 \ |
|
214 product(bool, CMSAbortSemantics, false, \ |
|
215 "Whether abort-on-overflow semantics is implemented") \ |
|
216 \ |
|
217 product(bool, CMSParallelInitialMarkEnabled, true, \ |
|
218 "Use the parallel initial mark.") \ |
|
219 \ |
|
220 product(bool, CMSParallelRemarkEnabled, true, \ |
|
221 "Whether parallel remark enabled (only if ParNewGC)") \ |
|
222 \ |
|
223 product(bool, CMSParallelSurvivorRemarkEnabled, true, \ |
|
224 "Whether parallel remark of survivor space " \ |
|
225 "enabled (effective only if CMSParallelRemarkEnabled)") \ |
|
226 \ |
|
227 product(bool, CMSPLABRecordAlways, true, \ |
|
228 "Always record survivor space PLAB boundaries (effective only " \ |
|
229 "if CMSParallelSurvivorRemarkEnabled)") \ |
|
230 \ |
|
231 product(bool, CMSEdenChunksRecordAlways, true, \ |
|
232 "Always record eden chunks used for the parallel initial mark " \ |
|
233 "or remark of eden") \ |
|
234 \ |
|
235 product(bool, CMSConcurrentMTEnabled, true, \ |
|
236 "Whether multi-threaded concurrent work enabled " \ |
|
237 "(effective only if ParNewGC)") \ |
|
238 \ |
|
239 product(bool, CMSPrecleaningEnabled, true, \ |
|
240 "Whether concurrent precleaning enabled") \ |
|
241 \ |
|
242 product(uintx, CMSPrecleanIter, 3, \ |
|
243 "Maximum number of precleaning iteration passes") \ |
|
244 range(0, 9) \ |
|
245 \ |
|
246 product(uintx, CMSPrecleanDenominator, 3, \ |
|
247 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \ |
|
248 "ratio") \ |
|
249 range(1, max_uintx) \ |
|
250 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \ |
|
251 \ |
|
252 product(uintx, CMSPrecleanNumerator, 2, \ |
|
253 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \ |
|
254 "ratio") \ |
|
255 range(0, max_uintx-1) \ |
|
256 constraint(CMSPrecleanNumeratorConstraintFunc,AfterErgo) \ |
|
257 \ |
|
258 product(bool, CMSPrecleanRefLists1, true, \ |
|
259 "Preclean ref lists during (initial) preclean phase") \ |
|
260 \ |
|
261 product(bool, CMSPrecleanRefLists2, false, \ |
|
262 "Preclean ref lists during abortable preclean phase") \ |
|
263 \ |
|
264 product(bool, CMSPrecleanSurvivors1, false, \ |
|
265 "Preclean survivors during (initial) preclean phase") \ |
|
266 \ |
|
267 product(bool, CMSPrecleanSurvivors2, true, \ |
|
268 "Preclean survivors during abortable preclean phase") \ |
|
269 \ |
|
270 product(uintx, CMSPrecleanThreshold, 1000, \ |
|
271 "Do not iterate again if number of dirty cards is less than this")\ |
|
272 range(100, max_uintx) \ |
|
273 \ |
|
274 product(bool, CMSCleanOnEnter, true, \ |
|
275 "Clean-on-enter optimization for reducing number of dirty cards") \ |
|
276 \ |
|
277 product(uintx, CMSRemarkVerifyVariant, 1, \ |
|
278 "Choose variant (1,2) of verification following remark") \ |
|
279 range(1, 2) \ |
|
280 \ |
|
281 product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \ |
|
282 "If Eden size is below this, do not try to schedule remark") \ |
|
283 range(0, max_uintx) \ |
|
284 \ |
|
285 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \ |
|
286 "The Eden occupancy percentage (0-100) at which " \ |
|
287 "to try and schedule remark pause") \ |
|
288 range(0, 100) \ |
|
289 \ |
|
290 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \ |
|
291 "Start sampling eden top at least before young gen " \ |
|
292 "occupancy reaches 1/<ratio> of the size at which " \ |
|
293 "we plan to schedule remark") \ |
|
294 range(1, max_uintx) \ |
|
295 \ |
|
296 product(uintx, CMSSamplingGrain, 16*K, \ |
|
297 "The minimum distance between eden samples for CMS (see above)") \ |
|
298 range(ObjectAlignmentInBytes, max_uintx) \ |
|
299 constraint(CMSSamplingGrainConstraintFunc,AfterMemoryInit) \ |
|
300 \ |
|
301 product(bool, CMSScavengeBeforeRemark, false, \ |
|
302 "Attempt scavenge before the CMS remark step") \ |
|
303 \ |
|
304 product(uintx, CMSWorkQueueDrainThreshold, 10, \ |
|
305 "Don't drain below this size per parallel worker/thief") \ |
|
306 range(1, max_juint) \ |
|
307 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \ |
|
308 \ |
|
309 manageable(intx, CMSWaitDuration, 2000, \ |
|
310 "Time in milliseconds that CMS thread waits for young GC") \ |
|
311 range(min_jint, max_jint) \ |
|
312 \ |
|
313 develop(uintx, CMSCheckInterval, 1000, \ |
|
314 "Interval in milliseconds that CMS thread checks if it " \ |
|
315 "should start a collection cycle") \ |
|
316 \ |
|
317 product(bool, CMSYield, true, \ |
|
318 "Yield between steps of CMS") \ |
|
319 \ |
|
320 product(size_t, CMSBitMapYieldQuantum, 10*M, \ |
|
321 "Bitmap operations should process at most this many bits " \ |
|
322 "between yields") \ |
|
323 range(1, max_uintx) \ |
|
324 constraint(CMSBitMapYieldQuantumConstraintFunc,AfterMemoryInit) \ |
|
325 \ |
|
326 product(bool, CMSPrintChunksInDump, false, \ |
|
327 "If logging for the \"gc\" and \"promotion\" tags is enabled on" \ |
|
328 "trace level include more detailed information about the" \ |
|
329 "free chunks") \ |
|
330 \ |
|
331 product(bool, CMSPrintObjectsInDump, false, \ |
|
332 "If logging for the \"gc\" and \"promotion\" tags is enabled on" \ |
|
333 "trace level include more detailed information about the" \ |
|
334 "allocated objects") \ |
|
335 \ |
|
336 diagnostic(bool, FLSVerifyAllHeapReferences, false, \ |
|
337 "Verify that all references across the FLS boundary " \ |
|
338 "are to valid objects") \ |
|
339 \ |
|
340 diagnostic(bool, FLSVerifyLists, false, \ |
|
341 "Do lots of (expensive) FreeListSpace verification") \ |
|
342 \ |
|
343 diagnostic(bool, FLSVerifyIndexTable, false, \ |
|
344 "Do lots of (expensive) FLS index table verification") \ |
|
345 \ |
|
346 product(uintx, CMSTriggerRatio, 80, \ |
|
347 "Percentage of MinHeapFreeRatio in CMS generation that is " \ |
|
348 "allocated before a CMS collection cycle commences") \ |
|
349 range(0, 100) \ |
|
350 \ |
|
351 product(uintx, CMSBootstrapOccupancy, 50, \ |
|
352 "Percentage CMS generation occupancy at which to " \ |
|
353 "initiate CMS collection for bootstrapping collection stats") \ |
|
354 range(0, 100) \ |
|
355 \ |
|
356 product(intx, CMSInitiatingOccupancyFraction, -1, \ |
|
357 "Percentage CMS generation occupancy to start a CMS collection " \ |
|
358 "cycle. A negative value means that CMSTriggerRatio is used") \ |
|
359 range(min_intx, 100) \ |
|
360 \ |
|
361 manageable(intx, CMSTriggerInterval, -1, \ |
|
362 "Commence a CMS collection cycle (at least) every so many " \ |
|
363 "milliseconds (0 permanently, -1 disabled)") \ |
|
364 range(-1, max_intx) \ |
|
365 \ |
|
366 product(bool, UseCMSInitiatingOccupancyOnly, false, \ |
|
367 "Only use occupancy as a criterion for starting a CMS collection")\ |
|
368 \ |
|
369 product(uintx, CMSIsTooFullPercentage, 98, \ |
|
370 "An absolute ceiling above which CMS will always consider the " \ |
|
371 "unloading of classes when class unloading is enabled") \ |
|
372 range(0, 100) \ |
|
373 \ |
|
374 develop(bool, CMSTestInFreeList, false, \ |
|
375 "Check if the coalesced range is already in the " \ |
|
376 "free lists as claimed") \ |
|
377 \ |
|
378 notproduct(bool, CMSVerifyReturnedBytes, false, \ |
|
379 "Check that all the garbage collected was returned to the " \ |
|
380 "free lists") \ |
|
381 \ |
|
382 diagnostic(bool, BindCMSThreadToCPU, false, \ |
|
383 "Bind CMS Thread to CPU if possible") \ |
|
384 \ |
|
385 diagnostic(uintx, CPUForCMSThread, 0, \ |
|
386 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \ |
|
387 range(0, max_juint) \ |
|
388 \ |
|
389 product(uintx, CMSCoordinatorYieldSleepCount, 10, \ |
|
390 "Number of times the coordinator GC thread will sleep while " \ |
|
391 "yielding before giving up and resuming GC") \ |
|
392 range(0, max_juint) \ |
|
393 \ |
|
394 product(uintx, CMSYieldSleepCount, 0, \ |
|
395 "Number of times a GC thread (minus the coordinator) " \ |
|
396 "will sleep while yielding before giving up and resuming GC") \ |
|
397 range(0, max_juint) \ |
|
398 \ |
|
399 product(bool, ParGCUseLocalOverflow, false, \ |
|
400 "Instead of a global overflow list, use local overflow stacks") \ |
|
401 \ |
|
402 product(bool, ParGCTrimOverflow, true, \ |
|
403 "Eagerly trim the local overflow lists " \ |
|
404 "(when ParGCUseLocalOverflow)") \ |
|
405 \ |
|
406 notproduct(bool, ParGCWorkQueueOverflowALot, false, \ |
|
407 "Simulate work queue overflow in ParNew") \ |
|
408 \ |
|
409 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \ |
|
410 "An `interval' counter that determines how frequently " \ |
|
411 "we simulate overflow; a smaller number increases frequency") \ |
|
412 \ |
|
413 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \ |
|
414 "The desired number of objects to claim from the overflow list") \ |
|
415 range(0, max_uintx) \ |
|
416 \ |
|
417 diagnostic(uintx, ParGCStridesPerThread, 2, \ |
|
418 "The number of strides per worker thread that we divide up the " \ |
|
419 "card table scanning work into") \ |
|
420 range(1, max_uintx) \ |
|
421 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \ |
|
422 \ |
|
423 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \ |
|
424 "The number of cards in each chunk of the parallel chunks used " \ |
|
425 "during card table scanning") \ |
|
426 range(1, max_intx) \ |
|
427 constraint(ParGCCardsPerStrideChunkConstraintFunc,AfterMemoryInit) |
|
428 |
|
429 #endif // SHARE_GC_CMS_CMS_GLOBALS_HPP |
|