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_VM_RUNTIME_GLOBALS_HPP
26 #define SHARE_VM_RUNTIME_GLOBALS_HPP
27
28 #include "utilities/debug.hpp"
29
30 // use this for flags that are true per default in the tiered build
31 // but false in non-tiered builds, and vice versa
32 #ifdef TIERED
33 #define trueInTiered true
34 #define falseInTiered false
35 #else
36 #define trueInTiered false
37 #define falseInTiered true
38 #endif
39
40 #ifdef TARGET_ARCH_x86
41 # include "globals_x86.hpp"
42 #endif
43 #ifdef TARGET_ARCH_sparc
44 # include "globals_sparc.hpp"
45 #endif
46 #ifdef TARGET_ARCH_zero
47 # include "globals_zero.hpp"
48 #endif
1534 \
1535 product(uintx, HeapFirstMaximumCompactionCount, 3, \
1536 "The collection count for the first maximum compaction") \
1537 \
1538 product(bool, UseMaximumCompactionOnSystemGC, true, \
1539 "Use maximum compaction in the Parallel Old garbage collector " \
1540 "for a system GC") \
1541 \
1542 product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
1543 "The mean used by the parallel compact dead wood " \
1544 "limiter (a number between 0-100)") \
1545 range(0, 100) \
1546 \
1547 product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
1548 "The standard deviation used by the parallel compact dead wood " \
1549 "limiter (a number between 0-100)") \
1550 range(0, 100) \
1551 \
1552 product(uint, ParallelGCThreads, 0, \
1553 "Number of parallel threads parallel gc will use") \
1554 \
1555 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1556 "Use semaphore synchronization for the GC Threads, " \
1557 "instead of synchronization based on mutexes") \
1558 \
1559 product(bool, UseDynamicNumberOfGCThreads, false, \
1560 "Dynamically choose the number of parallel threads " \
1561 "parallel gc will use") \
1562 \
1563 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1564 "Force dynamic selection of the number of " \
1565 "parallel threads parallel gc will use to aid debugging") \
1566 \
1567 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1568 "Size of heap (bytes) per GC thread used in calculating the " \
1569 "number of GC threads") \
1570 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1571 \
1572 product(bool, TraceDynamicGCThreads, false, \
1573 "Trace the dynamic GC thread usage") \
1574 \
1575 develop(bool, ParallelOldGCSplitALot, false, \
1576 "Provoke splitting (copying data from a young gen space to " \
1577 "multiple destination spaces)") \
1578 \
1579 develop(uintx, ParallelOldGCSplitInterval, 3, \
1580 "How often to provoke splitting a young gen space") \
1581 range(0, max_uintx) \
1582 \
1583 product(uint, ConcGCThreads, 0, \
1584 "Number of threads concurrent gc will use") \
1585 \
1586 product(size_t, YoungPLABSize, 4096, \
1587 "Size of young gen promotion LAB's (in HeapWords)") \
1588 constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
1589 \
1590 product(size_t, OldPLABSize, 1024, \
1591 "Size of old gen promotion LAB's (in HeapWords), or Number \
1592 of blocks to attempt to claim when refilling CMS LAB's") \
1593 \
1594 product(uintx, GCTaskTimeStampEntries, 200, \
1595 "Number of time stamp entries per gc worker thread") \
1596 range(1, max_uintx) \
1597 \
1598 product(bool, AlwaysTenure, false, \
1599 "Always tenure objects in eden (ParallelGC only)") \
1600 \
1601 product(bool, NeverTenure, false, \
1602 "Never tenure objects in eden, may tenure on overflow " \
1603 "(ParallelGC only)") \
1604 \
1605 product(bool, ScavengeBeforeFullGC, true, \
1606 "Scavenge youngest generation before each full GC.") \
1607 \
1608 develop(bool, ScavengeWithObjectsInToSpace, false, \
1609 "Allow scavenges to occur when to-space contains objects") \
1610 \
1611 product(bool, UseConcMarkSweepGC, false, \
1612 "Use Concurrent Mark-Sweep GC in the old generation") \
1680 "Instead of a global overflow list, use local overflow stacks") \
1681 \
1682 product(bool, ParGCTrimOverflow, true, \
1683 "Eagerly trim the local overflow lists " \
1684 "(when ParGCUseLocalOverflow)") \
1685 \
1686 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1687 "Simulate work queue overflow in ParNew") \
1688 \
1689 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1690 "An `interval' counter that determines how frequently " \
1691 "we simulate overflow; a smaller number increases frequency") \
1692 \
1693 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1694 "The desired number of objects to claim from the overflow list") \
1695 \
1696 diagnostic(uintx, ParGCStridesPerThread, 2, \
1697 "The number of strides per worker thread that we divide up the " \
1698 "card table scanning work into") \
1699 range(1, max_uintx) \
1700 \
1701 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1702 "The number of cards in each chunk of the parallel chunks used " \
1703 "during card table scanning") \
1704 range(1, max_intx) \
1705 \
1706 product(uintx, OldPLABWeight, 50, \
1707 "Percentage (0-100) used to weight the current sample when " \
1708 "computing exponentially decaying average for resizing " \
1709 "OldPLABSize") \
1710 range(0, 100) \
1711 \
1712 product(bool, ResizeOldPLAB, true, \
1713 "Dynamically resize (old gen) promotion LAB's") \
1714 \
1715 product(bool, PrintOldPLAB, false, \
1716 "Print (old gen) promotion LAB's sizing decisions") \
1717 \
1718 product(size_t, CMSOldPLABMax, 1024, \
1719 "Maximum size of CMS gen promotion LAB caches per worker " \
1720 "per block size") \
1721 range(1, max_uintx) \
1722 \
1723 product(size_t, CMSOldPLABMin, 16, \
1724 "Minimum size of CMS gen promotion LAB caches per worker " \
1725 "per block size") \
1726 range(1, max_uintx) \
1727 constraint(CMSOldPLABMinConstraintFunc,AfterErgo) \
1728 \
1729 product(uintx, CMSOldPLABNumRefills, 4, \
1730 "Nominal number of refills of CMS gen promotion LAB cache " \
1731 "per worker per block size") \
1732 range(1, max_uintx) \
1733 \
1734 product(bool, CMSOldPLABResizeQuicker, false, \
1735 "React on-the-fly during a scavenge to a sudden " \
1736 "change in block demand rate") \
1737 \
1738 product(uintx, CMSOldPLABToleranceFactor, 4, \
1739 "The tolerance of the phase-change detector for on-the-fly " \
1740 "PLAB resizing during a scavenge") \
1741 range(1, max_uintx) \
1742 \
1743 product(uintx, CMSOldPLABReactivityFactor, 2, \
1744 "The gain in the feedback loop for on-the-fly PLAB resizing " \
1745 "during a scavenge") \
1746 \
1747 product(bool, AlwaysPreTouch, false, \
1766 "Percentage (0-100) used to weight the current sample when " \
1767 "computing exponentially decaying averages for CMS FLS " \
1768 "statistics") \
1769 range(0, 100) \
1770 \
1771 product(uintx, CMS_FLSPadding, 1, \
1772 "The multiple of deviation from mean to use for buffering " \
1773 "against volatility in free list demand") \
1774 \
1775 product(uintx, FLSCoalescePolicy, 2, \
1776 "CMS: aggressiveness level for coalescing, increasing " \
1777 "from 0 to 4") \
1778 range(0, 4) \
1779 \
1780 product(bool, FLSAlwaysCoalesceLarge, false, \
1781 "CMS: larger free blocks are always available for coalescing") \
1782 \
1783 product(double, FLSLargestBlockCoalesceProximity, 0.99, \
1784 "CMS: the smaller the percentage the greater the coalescing " \
1785 "force") \
1786 \
1787 product(double, CMSSmallCoalSurplusPercent, 1.05, \
1788 "CMS: the factor by which to inflate estimated demand of small " \
1789 "block sizes to prevent coalescing with an adjoining block") \
1790 \
1791 product(double, CMSLargeCoalSurplusPercent, 0.95, \
1792 "CMS: the factor by which to inflate estimated demand of large " \
1793 "block sizes to prevent coalescing with an adjoining block") \
1794 \
1795 product(double, CMSSmallSplitSurplusPercent, 1.10, \
1796 "CMS: the factor by which to inflate estimated demand of small " \
1797 "block sizes to prevent splitting to supply demand for smaller " \
1798 "blocks") \
1799 \
1800 product(double, CMSLargeSplitSurplusPercent, 1.00, \
1801 "CMS: the factor by which to inflate estimated demand of large " \
1802 "block sizes to prevent splitting to supply demand for smaller " \
1803 "blocks") \
1804 \
1805 product(bool, CMSExtrapolateSweep, false, \
1806 "CMS: cushion for block demand during sweep") \
1807 \
1808 product(uintx, CMS_SweepWeight, 75, \
1809 "Percentage (0-100) used to weight the current sample when " \
1810 "computing exponentially decaying average for inter-sweep " \
1811 "duration") \
1812 range(0, 100) \
1813 \
1814 product(uintx, CMS_SweepPadding, 1, \
1815 "The multiple of deviation from mean to use for buffering " \
1816 "against volatility in inter-sweep duration") \
1817 \
1818 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
1819 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
1820 "duration exceeds this threshold in milliseconds") \
1821 \
1822 product(bool, CMSClassUnloadingEnabled, true, \
1823 "Whether class unloading enabled when using CMS GC") \
1824 \
1825 product(uintx, CMSClassUnloadingMaxInterval, 0, \
1826 "When CMS class unloading is enabled, the maximum CMS cycle " \
1827 "count for which classes may not be unloaded") \
1828 \
1829 develop(intx, CMSDictionaryChoice, 0, \
1830 "Use BinaryTreeDictionary as default in the CMS generation") \
1831 \
1832 product(uintx, CMSIndexedFreeListReplenish, 4, \
1833 "Replenish an indexed free list with this number of chunks") \
1834 \
1835 product(bool, CMSReplenishIntermediate, true, \
1836 "Replenish all intermediate free-list caches") \
1837 \
1838 product(bool, CMSSplitIndexedFreeListBlocks, true, \
1839 "When satisfying batched demand, split blocks from the " \
1840 "IndexedFreeList whose size is a multiple of requested size") \
1841 \
1842 product(bool, CMSLoopWarn, false, \
1843 "Warn in case of excessive CMS looping") \
1844 \
1845 develop(bool, CMSOverflowEarlyRestoration, false, \
1846 "Restore preserved marks early") \
1847 \
1848 product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
1849 "Size of marking stack") \
1850 \
1851 /* where does the range max value of (max_jint - 1) come from? */ \
1852 product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
1853 "Maximum size of marking stack") \
1854 range(1, (max_jint - 1)) \
1855 \
1856 notproduct(bool, CMSMarkStackOverflowALot, false, \
1857 "Simulate frequent marking stack / work queue overflow") \
1858 \
1859 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
1860 "An \"interval\" counter that determines how frequently " \
1861 "to simulate overflow; a smaller number increases frequency") \
1862 \
1863 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
1864 "Maximum number of abortable preclean iterations, if > 0") \
1865 \
1866 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
1867 "Maximum time in abortable preclean (in milliseconds)") \
1868 \
1869 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
1870 "Nominal minimum work per abortable preclean iteration") \
1871 \
1872 manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
1873 "Time that we sleep between iterations when not given " \
1874 "enough work per iteration") \
1875 \
1876 product(size_t, CMSRescanMultiple, 32, \
1877 "Size (in cards) of CMS parallel rescan task") \
1878 range(1, max_uintx) \
1879 \
1880 product(size_t, CMSConcMarkMultiple, 32, \
1881 "Size (in cards) of CMS concurrent MT marking task") \
1882 range(1, max_uintx) \
1883 \
1884 product(bool, CMSAbortSemantics, false, \
1885 "Whether abort-on-overflow semantics is implemented") \
1886 \
1887 product(bool, CMSParallelInitialMarkEnabled, true, \
1888 "Use the parallel initial mark.") \
1889 \
1890 product(bool, CMSParallelRemarkEnabled, true, \
1891 "Whether parallel remark enabled (only if ParNewGC)") \
1892 \
1893 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1894 "Whether parallel remark of survivor space " \
1961 range(0, 100) \
1962 \
1963 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1964 "Start sampling eden top at least before young gen " \
1965 "occupancy reaches 1/<ratio> of the size at which " \
1966 "we plan to schedule remark") \
1967 range(1, max_uintx) \
1968 \
1969 product(uintx, CMSSamplingGrain, 16*K, \
1970 "The minimum distance between eden samples for CMS (see above)") \
1971 range(1, max_uintx) \
1972 \
1973 product(bool, CMSScavengeBeforeRemark, false, \
1974 "Attempt scavenge before the CMS remark step") \
1975 \
1976 develop(bool, CMSTraceSweeper, false, \
1977 "Trace some actions of the CMS sweeper") \
1978 \
1979 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1980 "Don't drain below this size per parallel worker/thief") \
1981 \
1982 manageable(intx, CMSWaitDuration, 2000, \
1983 "Time in milliseconds that CMS thread waits for young GC") \
1984 \
1985 develop(uintx, CMSCheckInterval, 1000, \
1986 "Interval in milliseconds that CMS thread checks if it " \
1987 "should start a collection cycle") \
1988 \
1989 product(bool, CMSYield, true, \
1990 "Yield between steps of CMS") \
1991 \
1992 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1993 "Bitmap operations should process at most this many bits " \
1994 "between yields") \
1995 range(1, max_uintx) \
1996 \
1997 product(bool, CMSDumpAtPromotionFailure, false, \
1998 "Dump useful information about the state of the CMS old " \
1999 "generation upon a promotion failure") \
2000 \
2217 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2218 "Use adaptive survivor sizing policies") \
2219 \
2220 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2221 "Use adaptive young-old sizing policies at minor collections") \
2222 \
2223 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2224 "Use adaptive young-old sizing policies at major collections") \
2225 \
2226 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2227 "Include statistics from System.gc() for adaptive size policy") \
2228 \
2229 product(bool, UseAdaptiveGCBoundary, false, \
2230 "Allow young-old boundary to move") \
2231 \
2232 develop(bool, TraceAdaptiveGCBoundary, false, \
2233 "Trace young-old boundary moves") \
2234 \
2235 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2236 "Resize the virtual spaces of the young or old generations") \
2237 \
2238 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2239 "Policy for changing generation size for throughput goals") \
2240 \
2241 develop(bool, PSAdjustTenuredGenForMinorPause, false, \
2242 "Adjust tenured generation to achieve a minor pause goal") \
2243 \
2244 develop(bool, PSAdjustYoungGenForMajorPause, false, \
2245 "Adjust young generation to achieve a major pause goal") \
2246 \
2247 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2248 "Number of steps where heuristics is used before data is used") \
2249 \
2250 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2251 "Number of collections before the adaptive sizing is started") \
2252 \
2253 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2254 "Collection interval for printing information; zero means never") \
2255 \
2256 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2257 "Use adaptive minimum footprint as a goal") \
2258 \
2259 product(uintx, AdaptiveSizePolicyWeight, 10, \
2291 \
2292 product(uintx, YoungGenerationSizeSupplementDecay, 8, \
2293 "Decay factor to YoungedGenerationSizeSupplement") \
2294 range(1, max_uintx) \
2295 \
2296 product(uintx, TenuredGenerationSizeIncrement, 20, \
2297 "Adaptive size percentage change in tenured generation") \
2298 range(0, 100) \
2299 \
2300 product(uintx, TenuredGenerationSizeSupplement, 80, \
2301 "Supplement to TenuredGenerationSizeIncrement used at startup") \
2302 range(0, 100) \
2303 \
2304 product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
2305 "Decay factor to TenuredGenerationSizeIncrement") \
2306 range(1, max_uintx) \
2307 \
2308 product(uintx, MaxGCPauseMillis, max_uintx, \
2309 "Adaptive size policy maximum GC pause time goal in millisecond, "\
2310 "or (G1 Only) the maximum GC time per MMU time slice") \
2311 \
2312 product(uintx, GCPauseIntervalMillis, 0, \
2313 "Time slice for MMU specification") \
2314 \
2315 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
2316 "Adaptive size policy maximum GC minor pause time goal " \
2317 "in millisecond") \
2318 \
2319 product(uintx, GCTimeRatio, 99, \
2320 "Adaptive size policy application time to GC time ratio") \
2321 \
2322 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
2323 "Adaptive size scale down factor for shrinking") \
2324 range(1, max_uintx) \
2325 \
2326 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
2327 "Adaptive size decays the major cost for long major intervals") \
2328 \
2329 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
2330 "Time scale over which major costs decay") \
2331 \
2332 product(uintx, MinSurvivorRatio, 3, \
2333 "Minimum ratio of young generation/survivor space size") \
2334 \
2335 product(uintx, InitialSurvivorRatio, 8, \
2336 "Initial ratio of young generation/survivor space size") \
2337 \
2338 product(size_t, BaseFootPrintEstimate, 256*M, \
2339 "Estimate of footprint other than Java Heap") \
2340 \
2341 product(bool, UseGCOverheadLimit, true, \
2342 "Use policy to limit of proportion of time spent in GC " \
2343 "before an OutOfMemory error is thrown") \
2344 \
2345 product(uintx, GCTimeLimit, 98, \
2346 "Limit of the proportion of time spent in GC before " \
2347 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2348 range(0, 100) \
2349 \
2350 product(uintx, GCHeapFreeLimit, 2, \
2351 "Minimum percentage of free space after a full GC before an " \
2352 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2353 range(0, 100) \
2354 \
2355 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2356 "Number of consecutive collections before gc time limit fires") \
2357 \
2358 product(bool, PrintAdaptiveSizePolicy, false, \
2359 "Print information about AdaptiveSizePolicy") \
2360 \
2361 product(intx, PrefetchCopyIntervalInBytes, -1, \
2362 "How far ahead to prefetch destination area (<= 0 means off)") \
2363 \
2364 product(intx, PrefetchScanIntervalInBytes, -1, \
2365 "How far ahead to prefetch scan area (<= 0 means off)") \
2366 \
2367 product(intx, PrefetchFieldsAhead, -1, \
2368 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2369 \
2370 diagnostic(bool, VerifySilently, false, \
2371 "Do not print the verification progress") \
2372 \
2373 diagnostic(bool, VerifyDuringStartup, false, \
2374 "Verify memory system before executing any Java code " \
2375 "during VM initialization") \
2376 \
2436 "Print message at garbage collection") \
2437 \
2438 manageable(bool, PrintGCDetails, false, \
2439 "Print more details at garbage collection") \
2440 \
2441 manageable(bool, PrintGCDateStamps, false, \
2442 "Print date stamps at garbage collection") \
2443 \
2444 manageable(bool, PrintGCTimeStamps, false, \
2445 "Print timestamps at garbage collection") \
2446 \
2447 manageable(bool, PrintGCID, true, \
2448 "Print an identifier for each garbage collection") \
2449 \
2450 product(bool, PrintGCTaskTimeStamps, false, \
2451 "Print timestamps for individual gc worker thread tasks") \
2452 \
2453 develop(intx, ConcGCYieldTimeout, 0, \
2454 "If non-zero, assert that GC threads yield within this " \
2455 "number of milliseconds") \
2456 \
2457 product(bool, PrintReferenceGC, false, \
2458 "Print times spent handling reference objects during GC " \
2459 "(enabled only when PrintGCDetails)") \
2460 \
2461 develop(bool, TraceReferenceGC, false, \
2462 "Trace handling of soft/weak/final/phantom references") \
2463 \
2464 develop(bool, TraceFinalizerRegistration, false, \
2465 "Trace registration of final references") \
2466 \
2467 notproduct(bool, TraceScavenge, false, \
2468 "Trace scavenge") \
2469 \
2470 product(bool, IgnoreEmptyClassPaths, false, \
2471 "Ignore empty path elements in -classpath") \
2472 \
2473 product(bool, TraceClassPaths, false, \
2474 "Trace processing of class paths") \
2475 \
2476 product_rw(bool, TraceClassLoading, false, \
2477 "Trace all classes loaded") \
2478 \
2479 product(bool, TraceClassLoadingPreorder, false, \
2480 "Trace all classes loaded in order referenced (not loaded)") \
2481 \
2482 product_rw(bool, TraceClassUnloading, false, \
2483 "Trace unloading of classes") \
2484 \
2485 product_rw(bool, TraceLoaderConstraints, false, \
2486 "Trace loader constraints") \
2487 \
2488 develop(bool, TraceClassLoaderData, false, \
2489 "Trace class loader loader_data lifetime") \
2490 \
2491 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2492 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2493 "Initial size of the boot class loader data metaspace") \
2494 \
2495 product(bool, TraceYoungGenTime, false, \
2496 "Trace accumulated time for young collection") \
2497 \
2498 product(bool, TraceOldGenTime, false, \
2499 "Trace accumulated time for old collection") \
2500 \
2501 product(bool, PrintTenuringDistribution, false, \
2502 "Print tenuring age information") \
2503 \
2504 product_rw(bool, PrintHeapAtGC, false, \
2505 "Print heap layout before and after each GC") \
2506 \
2507 product_rw(bool, PrintHeapAtGCExtended, false, \
2508 "Print extended information about the layout of the heap " \
2509 "when -XX:+PrintHeapAtGC is set") \
2510 \
2511 product(bool, PrintHeapAtSIGBREAK, true, \
2512 "Print heap layout in response to SIGBREAK") \
2513 \
2550 \
2551 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2552 "Trace summary phase in ParallelOldGC") \
2553 \
2554 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2555 "Trace compaction phase in ParallelOldGC") \
2556 \
2557 develop(bool, TraceParallelOldGCDensePrefix, false, \
2558 "Trace dense prefix computation for ParallelOldGC") \
2559 \
2560 develop(bool, IgnoreLibthreadGPFault, false, \
2561 "Suppress workaround for libthread GP fault") \
2562 \
2563 product(bool, PrintJNIGCStalls, false, \
2564 "Print diagnostic message when GC is stalled " \
2565 "by JNI critical section") \
2566 \
2567 experimental(double, ObjectCountCutOffPercent, 0.5, \
2568 "The percentage of the used heap that the instances of a class " \
2569 "must occupy for the class to generate a trace event") \
2570 \
2571 /* GC log rotation setting */ \
2572 \
2573 product(bool, UseGCLogFileRotation, false, \
2574 "Rotate gclog files (for long running applications). It requires "\
2575 "-Xloggc:<filename>") \
2576 \
2577 product(uintx, NumberOfGCLogFiles, 0, \
2578 "Number of gclog files in rotation " \
2579 "(default: 0, no rotation)") \
2580 \
2581 product(size_t, GCLogFileSize, 8*K, \
2582 "GC log file size, requires UseGCLogFileRotation. " \
2583 "Set to 0 to only trigger rotation via jcmd") \
2584 \
2585 /* JVMTI heap profiling */ \
2586 \
2587 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2588 "Trace JVMTI object tagging calls") \
2589 \
3260 \
3261 develop(intx, InlineFrequencyRatio, 20, \
3262 "Ratio of call site execution to caller method invocation") \
3263 \
3264 develop_pd(intx, InlineFrequencyCount, \
3265 "Count of call site execution necessary to trigger frequent " \
3266 "inlining") \
3267 \
3268 develop(intx, InlineThrowCount, 50, \
3269 "Force inlining of interpreted methods that throw this often") \
3270 \
3271 develop(intx, InlineThrowMaxSize, 200, \
3272 "Force inlining of throwing methods smaller than this") \
3273 \
3274 develop(intx, ProfilerNodeSize, 1024, \
3275 "Size in K to allocate for the Profile Nodes of each thread") \
3276 \
3277 /* gc parameters */ \
3278 product(size_t, InitialHeapSize, 0, \
3279 "Initial heap size (in bytes); zero means use ergonomics") \
3280 \
3281 product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
3282 "Maximum heap size (in bytes)") \
3283 \
3284 product(size_t, OldSize, ScaleForWordSize(4*M), \
3285 "Initial tenured generation size (in bytes)") \
3286 \
3287 product(size_t, NewSize, ScaleForWordSize(1*M), \
3288 "Initial new generation size (in bytes)") \
3289 \
3290 product(size_t, MaxNewSize, max_uintx, \
3291 "Maximum new generation size (in bytes), max_uintx means set " \
3292 "ergonomically") \
3293 \
3294 product(size_t, PretenureSizeThreshold, 0, \
3295 "Maximum size in bytes of objects allocated in DefNew " \
3296 "generation; zero means no maximum") \
3297 \
3298 product(size_t, TLABSize, 0, \
3299 "Starting TLAB size (in bytes); zero means set ergonomically") \
3300 \
3301 product(size_t, MinTLABSize, 2*K, \
3302 "Minimum allowed TLAB size (in bytes)") \
3303 range(1, max_uintx) \
3304 \
3305 product(uintx, TLABAllocationWeight, 35, \
3306 "Allocation averaging weight") \
3307 range(0, 100) \
3308 \
3309 /* Limit the lower bound of this flag to 1 as it is used */ \
3310 /* in a division expression. */ \
3311 product(uintx, TLABWasteTargetPercent, 1, \
3312 "Percentage of Eden that can be wasted") \
3313 range(1, 100) \
3314 \
3315 product(uintx, TLABRefillWasteFraction, 64, \
3316 "Maximum TLAB waste at a refill (internal fragmentation)") \
3317 range(1, max_uintx) \
3318 \
3319 product(uintx, TLABWasteIncrement, 4, \
3320 "Increment allowed waste at slow allocation") \
3321 \
3322 product(uintx, SurvivorRatio, 8, \
3323 "Ratio of eden/survivor space size") \
3324 \
3325 product(uintx, NewRatio, 2, \
3326 "Ratio of old/new generation sizes") \
3327 \
3328 product_pd(size_t, NewSizeThreadIncrease, \
3329 "Additional size added to desired new generation size per " \
3330 "non-daemon thread (in bytes)") \
3331 \
3332 product_pd(size_t, MetaspaceSize, \
3333 "Initial size of Metaspaces (in bytes)") \
3334 \
3335 product(size_t, MaxMetaspaceSize, max_uintx, \
3336 "Maximum size of Metaspaces (in bytes)") \
3337 \
3338 product(size_t, CompressedClassSpaceSize, 1*G, \
3339 "Maximum size of class area in Metaspace when compressed " \
3340 "class pointers are used") \
3341 range(1*M, 3*G) \
3342 \
3343 manageable(uintx, MinHeapFreeRatio, 40, \
3344 "The minimum percentage of heap free after GC to avoid expansion."\
3345 " For most GCs this applies to the old generation. In G1 and" \
3346 " ParallelGC it applies to the whole heap.") \
3347 range(0, 100) \
3348 constraint(MinHeapFreeRatioConstraintFunc,AfterErgo) \
3349 \
3350 manageable(uintx, MaxHeapFreeRatio, 70, \
3351 "The maximum percentage of heap free after GC to avoid shrinking."\
3352 " For most GCs this applies to the old generation. In G1 and" \
3353 " ParallelGC it applies to the whole heap.") \
3354 range(0, 100) \
3355 constraint(MaxHeapFreeRatioConstraintFunc,AfterErgo) \
3356 \
3357 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
3358 "Number of milliseconds per MB of free space in the heap") \
3359 \
3360 product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
3361 "The minimum change in heap space due to GC (in bytes)") \
3362 \
3363 product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
3364 "The minimum expansion of Metaspace (in bytes)") \
3365 \
3366 product(uintx, MaxMetaspaceFreeRatio, 70, \
3367 "The maximum percentage of Metaspace free after GC to avoid " \
3368 "shrinking") \
3369 range(0, 100) \
3370 constraint(MaxMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3371 \
3372 product(uintx, MinMetaspaceFreeRatio, 40, \
3373 "The minimum percentage of Metaspace free after GC to avoid " \
3374 "expansion") \
3375 range(0, 99) \
3376 constraint(MinMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3377 \
3378 product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
3379 "The maximum expansion of Metaspace without full GC (in bytes)") \
3380 \
3381 product(uintx, QueuedAllocationWarningCount, 0, \
3382 "Number of times an allocation that queues behind a GC " \
3383 "will retry before printing a warning") \
3384 \
3385 diagnostic(uintx, VerifyGCStartAt, 0, \
3386 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
3387 \
3388 diagnostic(intx, VerifyGCLevel, 0, \
3389 "Generation level at which to start +VerifyBefore/AfterGC") \
3390 \
3391 product(uintx, MaxTenuringThreshold, 15, \
3392 "Maximum value for tenuring threshold") \
3393 range(0, markOopDesc::max_age + 1) \
3394 constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
3395 \
3396 product(uintx, InitialTenuringThreshold, 7, \
3397 "Initial value for tenuring threshold") \
3398 range(0, markOopDesc::max_age + 1) \
3399 constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
3400 \
3401 product(uintx, TargetSurvivorRatio, 50, \
3402 "Desired percentage of survivor space used after scavenge") \
3403 range(0, 100) \
3404 \
3405 product(uintx, MarkSweepDeadRatio, 5, \
3406 "Percentage (0-100) of the old gen allowed as dead wood. " \
3407 "Serial mark sweep treats this as both the minimum and maximum " \
3408 "value. " \
3409 "CMS uses this value only if it falls back to mark sweep. " \
3428 "Statistics for CMS' FreeListSpace") \
3429 \
3430 product(intx, PrintFLSCensus, 0, \
3431 "Census for CMS' FreeListSpace") \
3432 \
3433 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3434 "Delay between expansion and allocation (in milliseconds)") \
3435 \
3436 develop(uintx, GCWorkerDelayMillis, 0, \
3437 "Delay in scheduling GC workers (in milliseconds)") \
3438 \
3439 product(intx, DeferThrSuspendLoopCount, 4000, \
3440 "(Unstable) Number of times to iterate in safepoint loop " \
3441 "before blocking VM threads ") \
3442 \
3443 product(intx, DeferPollingPageLoopCount, -1, \
3444 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3445 "before changing safepoint polling page to RO ") \
3446 \
3447 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3448 \
3449 product(bool, PSChunkLargeArrays, true, \
3450 "Process large arrays in chunks") \
3451 \
3452 product(uintx, GCDrainStackTargetSize, 64, \
3453 "Number of entries we will try to leave on the stack " \
3454 "during parallel gc") \
3455 \
3456 /* stack parameters */ \
3457 product_pd(intx, StackYellowPages, \
3458 "Number of yellow zone (recoverable overflows) pages") \
3459 range(1, max_intx) \
3460 \
3461 product_pd(intx, StackRedPages, \
3462 "Number of red zone (unrecoverable overflows) pages") \
3463 range(1, max_intx) \
3464 \
3465 /* greater stack shadow pages can't generate instruction to bang stack */ \
3466 product_pd(intx, StackShadowPages, \
3467 "Number of shadow zone (for overflow checking) pages " \
|
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_VM_RUNTIME_GLOBALS_HPP
26 #define SHARE_VM_RUNTIME_GLOBALS_HPP
27
28 #include "utilities/debug.hpp"
29 #include <float.h> // for DBL_MAX
30
31 // use this for flags that are true per default in the tiered build
32 // but false in non-tiered builds, and vice versa
33 #ifdef TIERED
34 #define trueInTiered true
35 #define falseInTiered false
36 #else
37 #define trueInTiered false
38 #define falseInTiered true
39 #endif
40
41 #ifdef TARGET_ARCH_x86
42 # include "globals_x86.hpp"
43 #endif
44 #ifdef TARGET_ARCH_sparc
45 # include "globals_sparc.hpp"
46 #endif
47 #ifdef TARGET_ARCH_zero
48 # include "globals_zero.hpp"
49 #endif
1535 \
1536 product(uintx, HeapFirstMaximumCompactionCount, 3, \
1537 "The collection count for the first maximum compaction") \
1538 \
1539 product(bool, UseMaximumCompactionOnSystemGC, true, \
1540 "Use maximum compaction in the Parallel Old garbage collector " \
1541 "for a system GC") \
1542 \
1543 product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
1544 "The mean used by the parallel compact dead wood " \
1545 "limiter (a number between 0-100)") \
1546 range(0, 100) \
1547 \
1548 product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
1549 "The standard deviation used by the parallel compact dead wood " \
1550 "limiter (a number between 0-100)") \
1551 range(0, 100) \
1552 \
1553 product(uint, ParallelGCThreads, 0, \
1554 "Number of parallel threads parallel gc will use") \
1555 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1556 \
1557 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1558 "Use semaphore synchronization for the GC Threads, " \
1559 "instead of synchronization based on mutexes") \
1560 \
1561 product(bool, UseDynamicNumberOfGCThreads, false, \
1562 "Dynamically choose the number of parallel threads " \
1563 "parallel gc will use") \
1564 \
1565 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1566 "Force dynamic selection of the number of " \
1567 "parallel threads parallel gc will use to aid debugging") \
1568 \
1569 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1570 "Size of heap (bytes) per GC thread used in calculating the " \
1571 "number of GC threads") \
1572 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1573 \
1574 product(bool, TraceDynamicGCThreads, false, \
1575 "Trace the dynamic GC thread usage") \
1576 \
1577 develop(bool, ParallelOldGCSplitALot, false, \
1578 "Provoke splitting (copying data from a young gen space to " \
1579 "multiple destination spaces)") \
1580 \
1581 develop(uintx, ParallelOldGCSplitInterval, 3, \
1582 "How often to provoke splitting a young gen space") \
1583 range(0, max_uintx) \
1584 \
1585 product(uint, ConcGCThreads, 0, \
1586 "Number of threads concurrent gc will use") \
1587 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1588 \
1589 product(uintx, GCTaskTimeStampEntries, 200, \
1590 "Number of time stamp entries per gc worker thread") \
1591 range(1, max_uintx) \
1592 \
1593 product(bool, AlwaysTenure, false, \
1594 "Always tenure objects in eden (ParallelGC only)") \
1595 \
1596 product(bool, NeverTenure, false, \
1597 "Never tenure objects in eden, may tenure on overflow " \
1598 "(ParallelGC only)") \
1599 \
1600 product(bool, ScavengeBeforeFullGC, true, \
1601 "Scavenge youngest generation before each full GC.") \
1602 \
1603 develop(bool, ScavengeWithObjectsInToSpace, false, \
1604 "Allow scavenges to occur when to-space contains objects") \
1605 \
1606 product(bool, UseConcMarkSweepGC, false, \
1607 "Use Concurrent Mark-Sweep GC in the old generation") \
1675 "Instead of a global overflow list, use local overflow stacks") \
1676 \
1677 product(bool, ParGCTrimOverflow, true, \
1678 "Eagerly trim the local overflow lists " \
1679 "(when ParGCUseLocalOverflow)") \
1680 \
1681 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1682 "Simulate work queue overflow in ParNew") \
1683 \
1684 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1685 "An `interval' counter that determines how frequently " \
1686 "we simulate overflow; a smaller number increases frequency") \
1687 \
1688 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1689 "The desired number of objects to claim from the overflow list") \
1690 \
1691 diagnostic(uintx, ParGCStridesPerThread, 2, \
1692 "The number of strides per worker thread that we divide up the " \
1693 "card table scanning work into") \
1694 range(1, max_uintx) \
1695 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1696 \
1697 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1698 "The number of cards in each chunk of the parallel chunks used " \
1699 "during card table scanning") \
1700 range(1, max_intx) \
1701 \
1702 product(uintx, OldPLABWeight, 50, \
1703 "Percentage (0-100) used to weight the current sample when " \
1704 "computing exponentially decaying average for resizing " \
1705 "OldPLABSize") \
1706 range(0, 100) \
1707 \
1708 product(bool, ResizeOldPLAB, true, \
1709 "Dynamically resize (old gen) promotion LAB's") \
1710 \
1711 product(bool, PrintOldPLAB, false, \
1712 "Print (old gen) promotion LAB's sizing decisions") \
1713 \
1714 product(size_t, CMSOldPLABMax, 1024, \
1715 "Maximum size of CMS gen promotion LAB caches per worker " \
1716 "per block size") \
1717 range(1, max_uintx) \
1718 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1719 \
1720 product(size_t, CMSOldPLABMin, 16, \
1721 "Minimum size of CMS gen promotion LAB caches per worker " \
1722 "per block size") \
1723 range(1, max_uintx) \
1724 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1725 \
1726 product(uintx, CMSOldPLABNumRefills, 4, \
1727 "Nominal number of refills of CMS gen promotion LAB cache " \
1728 "per worker per block size") \
1729 range(1, max_uintx) \
1730 \
1731 product(bool, CMSOldPLABResizeQuicker, false, \
1732 "React on-the-fly during a scavenge to a sudden " \
1733 "change in block demand rate") \
1734 \
1735 product(uintx, CMSOldPLABToleranceFactor, 4, \
1736 "The tolerance of the phase-change detector for on-the-fly " \
1737 "PLAB resizing during a scavenge") \
1738 range(1, max_uintx) \
1739 \
1740 product(uintx, CMSOldPLABReactivityFactor, 2, \
1741 "The gain in the feedback loop for on-the-fly PLAB resizing " \
1742 "during a scavenge") \
1743 \
1744 product(bool, AlwaysPreTouch, false, \
1763 "Percentage (0-100) used to weight the current sample when " \
1764 "computing exponentially decaying averages for CMS FLS " \
1765 "statistics") \
1766 range(0, 100) \
1767 \
1768 product(uintx, CMS_FLSPadding, 1, \
1769 "The multiple of deviation from mean to use for buffering " \
1770 "against volatility in free list demand") \
1771 \
1772 product(uintx, FLSCoalescePolicy, 2, \
1773 "CMS: aggressiveness level for coalescing, increasing " \
1774 "from 0 to 4") \
1775 range(0, 4) \
1776 \
1777 product(bool, FLSAlwaysCoalesceLarge, false, \
1778 "CMS: larger free blocks are always available for coalescing") \
1779 \
1780 product(double, FLSLargestBlockCoalesceProximity, 0.99, \
1781 "CMS: the smaller the percentage the greater the coalescing " \
1782 "force") \
1783 range(0.0, 1.0) \
1784 \
1785 product(double, CMSSmallCoalSurplusPercent, 1.05, \
1786 "CMS: the factor by which to inflate estimated demand of small " \
1787 "block sizes to prevent coalescing with an adjoining block") \
1788 range(0.0, DBL_MAX) \
1789 \
1790 product(double, CMSLargeCoalSurplusPercent, 0.95, \
1791 "CMS: the factor by which to inflate estimated demand of large " \
1792 "block sizes to prevent coalescing with an adjoining block") \
1793 range(0.0, DBL_MAX) \
1794 \
1795 product(double, CMSSmallSplitSurplusPercent, 1.10, \
1796 "CMS: the factor by which to inflate estimated demand of small " \
1797 "block sizes to prevent splitting to supply demand for smaller " \
1798 "blocks") \
1799 range(0.0, DBL_MAX) \
1800 \
1801 product(double, CMSLargeSplitSurplusPercent, 1.00, \
1802 "CMS: the factor by which to inflate estimated demand of large " \
1803 "block sizes to prevent splitting to supply demand for smaller " \
1804 "blocks") \
1805 range(0.0, DBL_MAX) \
1806 \
1807 product(bool, CMSExtrapolateSweep, false, \
1808 "CMS: cushion for block demand during sweep") \
1809 \
1810 product(uintx, CMS_SweepWeight, 75, \
1811 "Percentage (0-100) used to weight the current sample when " \
1812 "computing exponentially decaying average for inter-sweep " \
1813 "duration") \
1814 range(0, 100) \
1815 \
1816 product(uintx, CMS_SweepPadding, 1, \
1817 "The multiple of deviation from mean to use for buffering " \
1818 "against volatility in inter-sweep duration") \
1819 \
1820 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
1821 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
1822 "duration exceeds this threshold in milliseconds") \
1823 \
1824 product(bool, CMSClassUnloadingEnabled, true, \
1825 "Whether class unloading enabled when using CMS GC") \
1826 \
1827 product(uintx, CMSClassUnloadingMaxInterval, 0, \
1828 "When CMS class unloading is enabled, the maximum CMS cycle " \
1829 "count for which classes may not be unloaded") \
1830 \
1831 develop(intx, CMSDictionaryChoice, 0, \
1832 "Use BinaryTreeDictionary as default in the CMS generation") \
1833 range(0, 2) \
1834 \
1835 product(uintx, CMSIndexedFreeListReplenish, 4, \
1836 "Replenish an indexed free list with this number of chunks") \
1837 range(1, max_uintx) \
1838 \
1839 product(bool, CMSReplenishIntermediate, true, \
1840 "Replenish all intermediate free-list caches") \
1841 \
1842 product(bool, CMSSplitIndexedFreeListBlocks, true, \
1843 "When satisfying batched demand, split blocks from the " \
1844 "IndexedFreeList whose size is a multiple of requested size") \
1845 \
1846 product(bool, CMSLoopWarn, false, \
1847 "Warn in case of excessive CMS looping") \
1848 \
1849 develop(bool, CMSOverflowEarlyRestoration, false, \
1850 "Restore preserved marks early") \
1851 \
1852 /* where does the range max value of (max_jint - 1) come from? */ \
1853 product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
1854 "Maximum size of marking stack") \
1855 range(1, (max_jint - 1)) \
1856 \
1857 product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
1858 "Size of marking stack") \
1859 range(0, MarkStackSizeMax) \
1860 \
1861 notproduct(bool, CMSMarkStackOverflowALot, false, \
1862 "Simulate frequent marking stack / work queue overflow") \
1863 \
1864 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
1865 "An \"interval\" counter that determines how frequently " \
1866 "to simulate overflow; a smaller number increases frequency") \
1867 \
1868 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
1869 "Maximum number of abortable preclean iterations, if > 0") \
1870 \
1871 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
1872 "Maximum time in abortable preclean (in milliseconds)") \
1873 range(0, max_intx) \
1874 \
1875 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
1876 "Nominal minimum work per abortable preclean iteration") \
1877 \
1878 manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
1879 "Time that we sleep between iterations when not given " \
1880 "enough work per iteration") \
1881 range(0, max_intx) \
1882 \
1883 product(size_t, CMSRescanMultiple, 32, \
1884 "Size (in cards) of CMS parallel rescan task") \
1885 range(1, max_uintx) \
1886 \
1887 product(size_t, CMSConcMarkMultiple, 32, \
1888 "Size (in cards) of CMS concurrent MT marking task") \
1889 range(1, max_uintx) \
1890 \
1891 product(bool, CMSAbortSemantics, false, \
1892 "Whether abort-on-overflow semantics is implemented") \
1893 \
1894 product(bool, CMSParallelInitialMarkEnabled, true, \
1895 "Use the parallel initial mark.") \
1896 \
1897 product(bool, CMSParallelRemarkEnabled, true, \
1898 "Whether parallel remark enabled (only if ParNewGC)") \
1899 \
1900 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1901 "Whether parallel remark of survivor space " \
1968 range(0, 100) \
1969 \
1970 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1971 "Start sampling eden top at least before young gen " \
1972 "occupancy reaches 1/<ratio> of the size at which " \
1973 "we plan to schedule remark") \
1974 range(1, max_uintx) \
1975 \
1976 product(uintx, CMSSamplingGrain, 16*K, \
1977 "The minimum distance between eden samples for CMS (see above)") \
1978 range(1, max_uintx) \
1979 \
1980 product(bool, CMSScavengeBeforeRemark, false, \
1981 "Attempt scavenge before the CMS remark step") \
1982 \
1983 develop(bool, CMSTraceSweeper, false, \
1984 "Trace some actions of the CMS sweeper") \
1985 \
1986 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1987 "Don't drain below this size per parallel worker/thief") \
1988 range(0, max_juint) \
1989 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1990 \
1991 manageable(intx, CMSWaitDuration, 2000, \
1992 "Time in milliseconds that CMS thread waits for young GC") \
1993 \
1994 develop(uintx, CMSCheckInterval, 1000, \
1995 "Interval in milliseconds that CMS thread checks if it " \
1996 "should start a collection cycle") \
1997 \
1998 product(bool, CMSYield, true, \
1999 "Yield between steps of CMS") \
2000 \
2001 product(size_t, CMSBitMapYieldQuantum, 10*M, \
2002 "Bitmap operations should process at most this many bits " \
2003 "between yields") \
2004 range(1, max_uintx) \
2005 \
2006 product(bool, CMSDumpAtPromotionFailure, false, \
2007 "Dump useful information about the state of the CMS old " \
2008 "generation upon a promotion failure") \
2009 \
2226 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2227 "Use adaptive survivor sizing policies") \
2228 \
2229 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2230 "Use adaptive young-old sizing policies at minor collections") \
2231 \
2232 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2233 "Use adaptive young-old sizing policies at major collections") \
2234 \
2235 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2236 "Include statistics from System.gc() for adaptive size policy") \
2237 \
2238 product(bool, UseAdaptiveGCBoundary, false, \
2239 "Allow young-old boundary to move") \
2240 \
2241 develop(bool, TraceAdaptiveGCBoundary, false, \
2242 "Trace young-old boundary moves") \
2243 \
2244 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2245 "Resize the virtual spaces of the young or old generations") \
2246 range(-1, 1) \
2247 \
2248 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2249 "Policy for changing generation size for throughput goals") \
2250 range(0, 1) \
2251 \
2252 develop(bool, PSAdjustTenuredGenForMinorPause, false, \
2253 "Adjust tenured generation to achieve a minor pause goal") \
2254 \
2255 develop(bool, PSAdjustYoungGenForMajorPause, false, \
2256 "Adjust young generation to achieve a major pause goal") \
2257 \
2258 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2259 "Number of steps where heuristics is used before data is used") \
2260 \
2261 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2262 "Number of collections before the adaptive sizing is started") \
2263 \
2264 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2265 "Collection interval for printing information; zero means never") \
2266 \
2267 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2268 "Use adaptive minimum footprint as a goal") \
2269 \
2270 product(uintx, AdaptiveSizePolicyWeight, 10, \
2302 \
2303 product(uintx, YoungGenerationSizeSupplementDecay, 8, \
2304 "Decay factor to YoungedGenerationSizeSupplement") \
2305 range(1, max_uintx) \
2306 \
2307 product(uintx, TenuredGenerationSizeIncrement, 20, \
2308 "Adaptive size percentage change in tenured generation") \
2309 range(0, 100) \
2310 \
2311 product(uintx, TenuredGenerationSizeSupplement, 80, \
2312 "Supplement to TenuredGenerationSizeIncrement used at startup") \
2313 range(0, 100) \
2314 \
2315 product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
2316 "Decay factor to TenuredGenerationSizeIncrement") \
2317 range(1, max_uintx) \
2318 \
2319 product(uintx, MaxGCPauseMillis, max_uintx, \
2320 "Adaptive size policy maximum GC pause time goal in millisecond, "\
2321 "or (G1 Only) the maximum GC time per MMU time slice") \
2322 range(1, max_uintx) \
2323 constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \
2324 \
2325 product(uintx, GCPauseIntervalMillis, 0, \
2326 "Time slice for MMU specification") \
2327 constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \
2328 \
2329 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
2330 "Adaptive size policy maximum GC minor pause time goal " \
2331 "in millisecond") \
2332 \
2333 product(uintx, GCTimeRatio, 99, \
2334 "Adaptive size policy application time to GC time ratio") \
2335 \
2336 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
2337 "Adaptive size scale down factor for shrinking") \
2338 range(1, max_uintx) \
2339 \
2340 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
2341 "Adaptive size decays the major cost for long major intervals") \
2342 \
2343 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
2344 "Time scale over which major costs decay") \
2345 \
2346 product(uintx, MinSurvivorRatio, 3, \
2347 "Minimum ratio of young generation/survivor space size") \
2348 range(3, max_uintx) \
2349 \
2350 product(uintx, InitialSurvivorRatio, 8, \
2351 "Initial ratio of young generation/survivor space size") \
2352 \
2353 product(size_t, BaseFootPrintEstimate, 256*M, \
2354 "Estimate of footprint other than Java Heap") \
2355 \
2356 product(bool, UseGCOverheadLimit, true, \
2357 "Use policy to limit of proportion of time spent in GC " \
2358 "before an OutOfMemory error is thrown") \
2359 \
2360 product(uintx, GCTimeLimit, 98, \
2361 "Limit of the proportion of time spent in GC before " \
2362 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2363 range(0, 100) \
2364 \
2365 product(uintx, GCHeapFreeLimit, 2, \
2366 "Minimum percentage of free space after a full GC before an " \
2367 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2368 range(0, 100) \
2369 \
2370 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2371 "Number of consecutive collections before gc time limit fires") \
2372 range(1, max_uintx) \
2373 \
2374 product(bool, PrintAdaptiveSizePolicy, false, \
2375 "Print information about AdaptiveSizePolicy") \
2376 \
2377 product(intx, PrefetchCopyIntervalInBytes, -1, \
2378 "How far ahead to prefetch destination area (<= 0 means off)") \
2379 \
2380 product(intx, PrefetchScanIntervalInBytes, -1, \
2381 "How far ahead to prefetch scan area (<= 0 means off)") \
2382 \
2383 product(intx, PrefetchFieldsAhead, -1, \
2384 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2385 \
2386 diagnostic(bool, VerifySilently, false, \
2387 "Do not print the verification progress") \
2388 \
2389 diagnostic(bool, VerifyDuringStartup, false, \
2390 "Verify memory system before executing any Java code " \
2391 "during VM initialization") \
2392 \
2452 "Print message at garbage collection") \
2453 \
2454 manageable(bool, PrintGCDetails, false, \
2455 "Print more details at garbage collection") \
2456 \
2457 manageable(bool, PrintGCDateStamps, false, \
2458 "Print date stamps at garbage collection") \
2459 \
2460 manageable(bool, PrintGCTimeStamps, false, \
2461 "Print timestamps at garbage collection") \
2462 \
2463 manageable(bool, PrintGCID, true, \
2464 "Print an identifier for each garbage collection") \
2465 \
2466 product(bool, PrintGCTaskTimeStamps, false, \
2467 "Print timestamps for individual gc worker thread tasks") \
2468 \
2469 develop(intx, ConcGCYieldTimeout, 0, \
2470 "If non-zero, assert that GC threads yield within this " \
2471 "number of milliseconds") \
2472 range(0, max_intx) \
2473 \
2474 product(bool, PrintReferenceGC, false, \
2475 "Print times spent handling reference objects during GC " \
2476 "(enabled only when PrintGCDetails)") \
2477 \
2478 develop(bool, TraceReferenceGC, false, \
2479 "Trace handling of soft/weak/final/phantom references") \
2480 \
2481 develop(bool, TraceFinalizerRegistration, false, \
2482 "Trace registration of final references") \
2483 \
2484 notproduct(bool, TraceScavenge, false, \
2485 "Trace scavenge") \
2486 \
2487 product(bool, IgnoreEmptyClassPaths, false, \
2488 "Ignore empty path elements in -classpath") \
2489 \
2490 product(bool, TraceClassPaths, false, \
2491 "Trace processing of class paths") \
2492 \
2493 product_rw(bool, TraceClassLoading, false, \
2494 "Trace all classes loaded") \
2495 \
2496 product(bool, TraceClassLoadingPreorder, false, \
2497 "Trace all classes loaded in order referenced (not loaded)") \
2498 \
2499 product_rw(bool, TraceClassUnloading, false, \
2500 "Trace unloading of classes") \
2501 \
2502 product_rw(bool, TraceLoaderConstraints, false, \
2503 "Trace loader constraints") \
2504 \
2505 develop(bool, TraceClassLoaderData, false, \
2506 "Trace class loader loader_data lifetime") \
2507 \
2508 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2509 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2510 "Initial size of the boot class loader data metaspace") \
2511 range(BytesPerWord, max_uintx) \
2512 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2513 \
2514 product(bool, TraceYoungGenTime, false, \
2515 "Trace accumulated time for young collection") \
2516 \
2517 product(bool, TraceOldGenTime, false, \
2518 "Trace accumulated time for old collection") \
2519 \
2520 product(bool, PrintTenuringDistribution, false, \
2521 "Print tenuring age information") \
2522 \
2523 product_rw(bool, PrintHeapAtGC, false, \
2524 "Print heap layout before and after each GC") \
2525 \
2526 product_rw(bool, PrintHeapAtGCExtended, false, \
2527 "Print extended information about the layout of the heap " \
2528 "when -XX:+PrintHeapAtGC is set") \
2529 \
2530 product(bool, PrintHeapAtSIGBREAK, true, \
2531 "Print heap layout in response to SIGBREAK") \
2532 \
2569 \
2570 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2571 "Trace summary phase in ParallelOldGC") \
2572 \
2573 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2574 "Trace compaction phase in ParallelOldGC") \
2575 \
2576 develop(bool, TraceParallelOldGCDensePrefix, false, \
2577 "Trace dense prefix computation for ParallelOldGC") \
2578 \
2579 develop(bool, IgnoreLibthreadGPFault, false, \
2580 "Suppress workaround for libthread GP fault") \
2581 \
2582 product(bool, PrintJNIGCStalls, false, \
2583 "Print diagnostic message when GC is stalled " \
2584 "by JNI critical section") \
2585 \
2586 experimental(double, ObjectCountCutOffPercent, 0.5, \
2587 "The percentage of the used heap that the instances of a class " \
2588 "must occupy for the class to generate a trace event") \
2589 range(0.0, 100.0) \
2590 \
2591 /* GC log rotation setting */ \
2592 \
2593 product(bool, UseGCLogFileRotation, false, \
2594 "Rotate gclog files (for long running applications). It requires "\
2595 "-Xloggc:<filename>") \
2596 \
2597 product(uintx, NumberOfGCLogFiles, 0, \
2598 "Number of gclog files in rotation " \
2599 "(default: 0, no rotation)") \
2600 \
2601 product(size_t, GCLogFileSize, 8*K, \
2602 "GC log file size, requires UseGCLogFileRotation. " \
2603 "Set to 0 to only trigger rotation via jcmd") \
2604 \
2605 /* JVMTI heap profiling */ \
2606 \
2607 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2608 "Trace JVMTI object tagging calls") \
2609 \
3280 \
3281 develop(intx, InlineFrequencyRatio, 20, \
3282 "Ratio of call site execution to caller method invocation") \
3283 \
3284 develop_pd(intx, InlineFrequencyCount, \
3285 "Count of call site execution necessary to trigger frequent " \
3286 "inlining") \
3287 \
3288 develop(intx, InlineThrowCount, 50, \
3289 "Force inlining of interpreted methods that throw this often") \
3290 \
3291 develop(intx, InlineThrowMaxSize, 200, \
3292 "Force inlining of throwing methods smaller than this") \
3293 \
3294 develop(intx, ProfilerNodeSize, 1024, \
3295 "Size in K to allocate for the Profile Nodes of each thread") \
3296 \
3297 /* gc parameters */ \
3298 product(size_t, InitialHeapSize, 0, \
3299 "Initial heap size (in bytes); zero means use ergonomics") \
3300 range(0, max_uintx) \
3301 constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
3302 \
3303 product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
3304 "Maximum heap size (in bytes)") \
3305 constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
3306 \
3307 product(size_t, OldSize, ScaleForWordSize(4*M), \
3308 "Initial tenured generation size (in bytes)") \
3309 \
3310 product(size_t, NewSize, ScaleForWordSize(1*M), \
3311 "Initial new generation size (in bytes)") \
3312 constraint(NewSizeConstraintFunc,AfterErgo) \
3313 \
3314 product(size_t, MaxNewSize, max_uintx, \
3315 "Maximum new generation size (in bytes), max_uintx means set " \
3316 "ergonomically") \
3317 \
3318 product(size_t, PretenureSizeThreshold, 0, \
3319 "Maximum size in bytes of objects allocated in DefNew " \
3320 "generation; zero means no maximum") \
3321 \
3322 product(size_t, MinTLABSize, 2*K, \
3323 "Minimum allowed TLAB size (in bytes)") \
3324 range(1, max_uintx) \
3325 constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
3326 \
3327 product(size_t, TLABSize, 0, \
3328 "Starting TLAB size (in bytes); zero means set ergonomically") \
3329 constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
3330 \
3331 product(size_t, YoungPLABSize, 4096, \
3332 "Size of young gen promotion LAB's (in HeapWords)") \
3333 constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
3334 \
3335 product(size_t, OldPLABSize, 1024, \
3336 "Size of old gen promotion LAB's (in HeapWords), or Number " \
3337 "of blocks to attempt to claim when refilling CMS LAB's") \
3338 constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
3339 \
3340 product(uintx, TLABAllocationWeight, 35, \
3341 "Allocation averaging weight") \
3342 range(0, 100) \
3343 \
3344 /* Limit the lower bound of this flag to 1 as it is used */ \
3345 /* in a division expression. */ \
3346 product(uintx, TLABWasteTargetPercent, 1, \
3347 "Percentage of Eden that can be wasted") \
3348 range(1, 100) \
3349 \
3350 product(uintx, TLABRefillWasteFraction, 64, \
3351 "Maximum TLAB waste at a refill (internal fragmentation)") \
3352 range(1, max_uintx) \
3353 \
3354 product(uintx, TLABWasteIncrement, 4, \
3355 "Increment allowed waste at slow allocation") \
3356 \
3357 product(uintx, SurvivorRatio, 8, \
3358 "Ratio of eden/survivor space size") \
3359 range(1, max_uintx-2) \
3360 constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
3361 \
3362 product(uintx, NewRatio, 2, \
3363 "Ratio of old/new generation sizes") \
3364 range(0, max_uintx-1) \
3365 \
3366 product_pd(size_t, NewSizeThreadIncrease, \
3367 "Additional size added to desired new generation size per " \
3368 "non-daemon thread (in bytes)") \
3369 \
3370 product_pd(size_t, MetaspaceSize, \
3371 "Initial size of Metaspaces (in bytes)") \
3372 constraint(MetaspaceSizeConstraintFunc,AfterErgo) \
3373 \
3374 product(size_t, MaxMetaspaceSize, max_uintx, \
3375 "Maximum size of Metaspaces (in bytes)") \
3376 constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo) \
3377 \
3378 product(size_t, CompressedClassSpaceSize, 1*G, \
3379 "Maximum size of class area in Metaspace when compressed " \
3380 "class pointers are used") \
3381 range(1*M, 3*G) \
3382 \
3383 manageable(uintx, MinHeapFreeRatio, 40, \
3384 "The minimum percentage of heap free after GC to avoid expansion."\
3385 " For most GCs this applies to the old generation. In G1 and" \
3386 " ParallelGC it applies to the whole heap.") \
3387 range(0, 100) \
3388 constraint(MinHeapFreeRatioConstraintFunc,AfterErgo) \
3389 \
3390 manageable(uintx, MaxHeapFreeRatio, 70, \
3391 "The maximum percentage of heap free after GC to avoid shrinking."\
3392 " For most GCs this applies to the old generation. In G1 and" \
3393 " ParallelGC it applies to the whole heap.") \
3394 range(0, 100) \
3395 constraint(MaxHeapFreeRatioConstraintFunc,AfterErgo) \
3396 \
3397 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
3398 "Number of milliseconds per MB of free space in the heap") \
3399 range(0, max_intx) \
3400 constraint(SoftRefLRUPolicyMSPerMBConstraintFunc,AfterMemoryInit) \
3401 \
3402 product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
3403 "The minimum change in heap space due to GC (in bytes)") \
3404 \
3405 product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
3406 "The minimum expansion of Metaspace (in bytes)") \
3407 \
3408 product(uintx, MaxMetaspaceFreeRatio, 70, \
3409 "The maximum percentage of Metaspace free after GC to avoid " \
3410 "shrinking") \
3411 range(0, 100) \
3412 constraint(MaxMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3413 \
3414 product(uintx, MinMetaspaceFreeRatio, 40, \
3415 "The minimum percentage of Metaspace free after GC to avoid " \
3416 "expansion") \
3417 range(0, 99) \
3418 constraint(MinMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3419 \
3420 product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
3421 "The maximum expansion of Metaspace without full GC (in bytes)") \
3422 \
3423 product(uintx, QueuedAllocationWarningCount, 0, \
3424 "Number of times an allocation that queues behind a GC " \
3425 "will retry before printing a warning") \
3426 \
3427 diagnostic(uintx, VerifyGCStartAt, 0, \
3428 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
3429 \
3430 diagnostic(intx, VerifyGCLevel, 0, \
3431 "Generation level at which to start +VerifyBefore/AfterGC") \
3432 range(0, 1) \
3433 \
3434 product(uintx, MaxTenuringThreshold, 15, \
3435 "Maximum value for tenuring threshold") \
3436 range(0, markOopDesc::max_age + 1) \
3437 constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
3438 \
3439 product(uintx, InitialTenuringThreshold, 7, \
3440 "Initial value for tenuring threshold") \
3441 range(0, markOopDesc::max_age + 1) \
3442 constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
3443 \
3444 product(uintx, TargetSurvivorRatio, 50, \
3445 "Desired percentage of survivor space used after scavenge") \
3446 range(0, 100) \
3447 \
3448 product(uintx, MarkSweepDeadRatio, 5, \
3449 "Percentage (0-100) of the old gen allowed as dead wood. " \
3450 "Serial mark sweep treats this as both the minimum and maximum " \
3451 "value. " \
3452 "CMS uses this value only if it falls back to mark sweep. " \
3471 "Statistics for CMS' FreeListSpace") \
3472 \
3473 product(intx, PrintFLSCensus, 0, \
3474 "Census for CMS' FreeListSpace") \
3475 \
3476 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3477 "Delay between expansion and allocation (in milliseconds)") \
3478 \
3479 develop(uintx, GCWorkerDelayMillis, 0, \
3480 "Delay in scheduling GC workers (in milliseconds)") \
3481 \
3482 product(intx, DeferThrSuspendLoopCount, 4000, \
3483 "(Unstable) Number of times to iterate in safepoint loop " \
3484 "before blocking VM threads ") \
3485 \
3486 product(intx, DeferPollingPageLoopCount, -1, \
3487 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3488 "before changing safepoint polling page to RO ") \
3489 \
3490 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3491 range(0, max_intx) \
3492 \
3493 product(bool, PSChunkLargeArrays, true, \
3494 "Process large arrays in chunks") \
3495 \
3496 product(uintx, GCDrainStackTargetSize, 64, \
3497 "Number of entries we will try to leave on the stack " \
3498 "during parallel gc") \
3499 \
3500 /* stack parameters */ \
3501 product_pd(intx, StackYellowPages, \
3502 "Number of yellow zone (recoverable overflows) pages") \
3503 range(1, max_intx) \
3504 \
3505 product_pd(intx, StackRedPages, \
3506 "Number of red zone (unrecoverable overflows) pages") \
3507 range(1, max_intx) \
3508 \
3509 /* greater stack shadow pages can't generate instruction to bang stack */ \
3510 product_pd(intx, StackShadowPages, \
3511 "Number of shadow zone (for overflow checking) pages " \
|