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