8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
26 #define SHARE_VM_RUNTIME_GLOBALS_HPP
27
28 #include <float.h>
29 #include "utilities/debug.hpp"
30 #include <float.h> // for DBL_MAX
31
32 // use this for flags that are true per default in the tiered build
33 // but false in non-tiered builds, and vice versa
34 #ifdef TIERED
35 #define trueInTiered true
36 #define falseInTiered false
37 #else
38 #define trueInTiered false
39 #define falseInTiered true
40 #endif
41
42 #ifdef TARGET_ARCH_x86
43 # include "globals_x86.hpp"
44 #endif
45 #ifdef TARGET_ARCH_sparc
46 # include "globals_sparc.hpp"
47 #endif
48 #ifdef TARGET_ARCH_zero
610 //
611 // constraint is a macro that will expand to custom function call
612 // for constraint checking if provided - see commandLineFlagConstraintList.hpp
613 //
614
615 #define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product, range, constraint) \
616 \
617 lp64_product(bool, UseCompressedOops, false, \
618 "Use 32-bit object references in 64-bit VM. " \
619 "lp64_product means flag is always constant in 32 bit VM") \
620 \
621 lp64_product(bool, UseCompressedClassPointers, false, \
622 "Use 32-bit class pointers in 64-bit VM. " \
623 "lp64_product means flag is always constant in 32 bit VM") \
624 \
625 notproduct(bool, CheckCompressedOops, true, \
626 "Generate checks in encoding/decoding code in debug VM") \
627 \
628 product_pd(size_t, HeapBaseMinAddress, \
629 "OS specific low limit for heap base address") \
630 \
631 product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \
632 "Heap allocation steps through preferred address regions to find" \
633 " where it can allocate the heap. Number of steps to take per " \
634 "region.") \
635 range(1, max_uintx) \
636 \
637 diagnostic(bool, PrintCompressedOopsMode, false, \
638 "Print compressed oops base address and encoding mode") \
639 \
640 lp64_product(intx, ObjectAlignmentInBytes, 8, \
641 "Default object alignment in bytes, 8 is minimum") \
642 range(8, 256) \
643 constraint(ObjectAlignmentInBytesConstraintFunc,AtParse) \
644 \
645 product(bool, AssumeMP, false, \
646 "Instruct the VM to assume multiple processors are available") \
647 \
648 /* UseMembar is theoretically a temp flag used for memory barrier */ \
649 /* removal testing. It was supposed to be removed before FCS but has */ \
675 "Allocate large pages individually for better affinity") \
676 \
677 develop(bool, LargePagesIndividualAllocationInjectError, false, \
678 "Fail large pages individual allocation") \
679 \
680 product(bool, UseLargePagesInMetaspace, false, \
681 "Use large page memory in metaspace. " \
682 "Only used if UseLargePages is enabled.") \
683 \
684 develop(bool, TracePageSizes, false, \
685 "Trace page size selection and usage") \
686 \
687 product(bool, UseNUMA, false, \
688 "Use NUMA if available") \
689 \
690 product(bool, UseNUMAInterleaving, false, \
691 "Interleave memory across NUMA nodes if available") \
692 \
693 product(size_t, NUMAInterleaveGranularity, 2*M, \
694 "Granularity to use for NUMA interleaving on Windows OS") \
695 \
696 product(bool, ForceNUMA, false, \
697 "Force NUMA optimizations on single-node/UMA systems") \
698 \
699 product(uintx, NUMAChunkResizeWeight, 20, \
700 "Percentage (0-100) used to weight the current sample when " \
701 "computing exponentially decaying average for " \
702 "AdaptiveNUMAChunkSizing") \
703 range(0, 100) \
704 \
705 product(size_t, NUMASpaceResizeRate, 1*G, \
706 "Do not reallocate more than this amount per collection") \
707 \
708 product(bool, UseAdaptiveNUMAChunkSizing, true, \
709 "Enable adaptive chunk sizing for NUMA") \
710 \
711 product(bool, NUMAStats, false, \
712 "Print NUMA stats in detailed heap information") \
713 \
714 product(uintx, NUMAPageScanRate, 256, \
715 "Maximum number of pages to include in the page scan procedure") \
716 \
717 product_pd(bool, NeedsDeoptSuspend, \
718 "True for register window machines (sparc/ia64)") \
719 \
720 product(intx, UseSSE, 99, \
721 "Highest supported SSE instructions set on x86/x64") \
722 range(0, 99) \
723 \
724 product(bool, UseAES, false, \
725 "Control whether AES instructions can be used on x86/x64") \
726 \
727 product(bool, UseSHA, false, \
728 "Control whether SHA instructions can be used " \
729 "on SPARC and on ARM") \
730 \
731 product(bool, UseGHASHIntrinsics, false, \
732 "Use intrinsics for GHASH versions of crypto") \
733 \
734 product(size_t, LargePageSizeInBytes, 0, \
735 "Large page size (0 to let VM choose the page size)") \
736 \
737 product(size_t, LargePageHeapSizeThreshold, 128*M, \
738 "Use large pages if maximum heap is at least this big") \
739 \
740 product(bool, ForceTimeHighResolution, false, \
741 "Using high time resolution (for Win32 only)") \
742 \
743 develop(bool, TraceItables, false, \
744 "Trace initialization and use of itables") \
745 \
746 develop(bool, TracePcPatching, false, \
747 "Trace usage of frame::patch_pc") \
748 \
749 develop(bool, TraceJumps, false, \
750 "Trace assembly jumps in thread ring buffer") \
751 \
752 develop(bool, TraceRelocator, false, \
753 "Trace the bytecode relocator") \
754 \
755 develop(bool, TraceLongCompiles, false, \
756 "Print out every time compilation is longer than " \
757 "a given threshold") \
758 \
1515 product(bool, TraceMonitorInflation, false, \
1516 "Trace monitor inflation in JVM") \
1517 \
1518 /* gc */ \
1519 \
1520 product(bool, UseSerialGC, false, \
1521 "Use the Serial garbage collector") \
1522 \
1523 product(bool, UseG1GC, false, \
1524 "Use the Garbage-First garbage collector") \
1525 \
1526 product(bool, UseParallelGC, false, \
1527 "Use the Parallel Scavenge garbage collector") \
1528 \
1529 product(bool, UseParallelOldGC, false, \
1530 "Use the Parallel Old garbage collector") \
1531 \
1532 product(uintx, HeapMaximumCompactionInterval, 20, \
1533 "How often should we maximally compact the heap (not allowing " \
1534 "any dead space)") \
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, \
1599 "A System.gc() request invokes a concurrent collection; " \
1600 "(effective only when using concurrent collectors)") \
1601 \
1602 product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
1603 "A System.gc() request invokes a concurrent collection and " \
1604 "also unloads classes during such a concurrent gc cycle " \
1605 "(effective only when UseConcMarkSweepGC)") \
1606 \
1607 product(bool, GCLockerInvokesConcurrent, false, \
1608 "The exit of a JNI critical section necessitating a scavenge, " \
1609 "also kicks off a background concurrent collection") \
1610 \
1611 product(uintx, GCLockerEdenExpansionPercent, 5, \
1612 "How much the GC can expand the eden by while the GC locker " \
1613 "is active (as a percentage)") \
1614 range(0, 100) \
1615 \
1616 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1617 "Number of times to retry allocations when " \
1618 "blocked by the GC locker") \
1619 \
1620 product(bool, UseCMSBestFit, true, \
1621 "Use CMS best fit allocation strategy") \
1622 \
1623 product(bool, UseParNewGC, false, \
1624 "Use parallel threads in the new generation") \
1625 \
1626 product(bool, PrintTaskqueue, false, \
1627 "Print taskqueue statistics for parallel collectors") \
1628 \
1629 product(bool, PrintTerminationStats, false, \
1630 "Print termination statistics for parallel collectors") \
1631 \
1632 product(uintx, ParallelGCBufferWastePct, 10, \
1633 "Wasted fraction of parallel allocation buffer") \
1634 range(0, 100) \
1635 \
1636 product(uintx, TargetPLABWastePct, 10, \
1637 "Target wasted space in last buffer as percent of overall " \
1638 "allocation") \
1653 "Scan a subset of object array and push remainder, if array is " \
1654 "bigger than this") \
1655 range(1, max_intx) \
1656 \
1657 product(bool, ParGCUseLocalOverflow, false, \
1658 "Instead of a global overflow list, use local overflow stacks") \
1659 \
1660 product(bool, ParGCTrimOverflow, true, \
1661 "Eagerly trim the local overflow lists " \
1662 "(when ParGCUseLocalOverflow)") \
1663 \
1664 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1665 "Simulate work queue overflow in ParNew") \
1666 \
1667 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1668 "An `interval' counter that determines how frequently " \
1669 "we simulate overflow; a smaller number increases frequency") \
1670 \
1671 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1672 "The desired number of objects to claim from the overflow list") \
1673 \
1674 diagnostic(uintx, ParGCStridesPerThread, 2, \
1675 "The number of strides per worker thread that we divide up the " \
1676 "card table scanning work into") \
1677 range(1, max_uintx) \
1678 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1679 \
1680 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1681 "The number of cards in each chunk of the parallel chunks used " \
1682 "during card table scanning") \
1683 range(1, max_intx) \
1684 \
1685 product(uintx, OldPLABWeight, 50, \
1686 "Percentage (0-100) used to weight the current sample when " \
1687 "computing exponentially decaying average for resizing " \
1688 "OldPLABSize") \
1689 range(0, 100) \
1690 \
1691 product(bool, ResizeOldPLAB, true, \
1692 "Dynamically resize (old gen) promotion LAB's") \
1706 range(1, max_uintx) \
1707 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1708 \
1709 product(uintx, CMSOldPLABNumRefills, 4, \
1710 "Nominal number of refills of CMS gen promotion LAB cache " \
1711 "per worker per block size") \
1712 range(1, max_uintx) \
1713 \
1714 product(bool, CMSOldPLABResizeQuicker, false, \
1715 "React on-the-fly during a scavenge to a sudden " \
1716 "change in block demand rate") \
1717 \
1718 product(uintx, CMSOldPLABToleranceFactor, 4, \
1719 "The tolerance of the phase-change detector for on-the-fly " \
1720 "PLAB resizing during a scavenge") \
1721 range(1, max_uintx) \
1722 \
1723 product(uintx, CMSOldPLABReactivityFactor, 2, \
1724 "The gain in the feedback loop for on-the-fly PLAB resizing " \
1725 "during a scavenge") \
1726 \
1727 product(bool, AlwaysPreTouch, false, \
1728 "Force all freshly committed pages to be pre-touched") \
1729 \
1730 product_pd(size_t, CMSYoungGenPerWorker, \
1731 "The maximum size of young gen chosen by default per GC worker " \
1732 "thread available") \
1733 range(1, max_uintx) \
1734 \
1735 product(uintx, CMSIncrementalSafetyFactor, 10, \
1736 "Percentage (0-100) used to add conservatism when computing the " \
1737 "duty cycle") \
1738 range(0, 100) \
1739 \
1740 product(uintx, CMSExpAvgFactor, 50, \
1741 "Percentage (0-100) used to weight the current sample when " \
1742 "computing exponential averages for CMS statistics") \
1743 range(0, 100) \
1744 \
1745 product(uintx, CMS_FLSWeight, 75, \
1746 "Percentage (0-100) used to weight the current sample when " \
1747 "computing exponentially decaying averages for CMS FLS " \
1748 "statistics") \
1749 range(0, 100) \
1750 \
1751 product(uintx, CMS_FLSPadding, 1, \
1752 "The multiple of deviation from mean to use for buffering " \
1753 "against volatility in free list demand") \
1754 \
1755 product(uintx, FLSCoalescePolicy, 2, \
1756 "CMS: aggressiveness level for coalescing, increasing " \
1757 "from 0 to 4") \
1758 range(0, 4) \
1759 \
1760 product(bool, FLSAlwaysCoalesceLarge, false, \
1761 "CMS: larger free blocks are always available for coalescing") \
1762 \
1763 product(double, FLSLargestBlockCoalesceProximity, 0.99, \
1764 "CMS: the smaller the percentage the greater the coalescing " \
1765 "force") \
1766 range(0.0, 1.0) \
1767 \
1768 product(double, CMSSmallCoalSurplusPercent, 1.05, \
1769 "CMS: the factor by which to inflate estimated demand of small " \
1770 "block sizes to prevent coalescing with an adjoining block") \
1771 range(0.0, DBL_MAX) \
1772 \
1773 product(double, CMSLargeCoalSurplusPercent, 0.95, \
1782 range(0.0, DBL_MAX) \
1783 \
1784 product(double, CMSLargeSplitSurplusPercent, 1.00, \
1785 "CMS: the factor by which to inflate estimated demand of large " \
1786 "block sizes to prevent splitting to supply demand for smaller " \
1787 "blocks") \
1788 range(0.0, DBL_MAX) \
1789 \
1790 product(bool, CMSExtrapolateSweep, false, \
1791 "CMS: cushion for block demand during sweep") \
1792 \
1793 product(uintx, CMS_SweepWeight, 75, \
1794 "Percentage (0-100) used to weight the current sample when " \
1795 "computing exponentially decaying average for inter-sweep " \
1796 "duration") \
1797 range(0, 100) \
1798 \
1799 product(uintx, CMS_SweepPadding, 1, \
1800 "The multiple of deviation from mean to use for buffering " \
1801 "against volatility in inter-sweep duration") \
1802 \
1803 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
1804 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
1805 "duration exceeds this threshold in milliseconds") \
1806 \
1807 product(bool, CMSClassUnloadingEnabled, true, \
1808 "Whether class unloading enabled when using CMS GC") \
1809 \
1810 product(uintx, CMSClassUnloadingMaxInterval, 0, \
1811 "When CMS class unloading is enabled, the maximum CMS cycle " \
1812 "count for which classes may not be unloaded") \
1813 \
1814 product(uintx, CMSIndexedFreeListReplenish, 4, \
1815 "Replenish an indexed free list with this number of chunks") \
1816 range(1, max_uintx) \
1817 \
1818 product(bool, CMSReplenishIntermediate, true, \
1819 "Replenish all intermediate free-list caches") \
1820 \
1821 product(bool, CMSSplitIndexedFreeListBlocks, true, \
1822 "When satisfying batched demand, split blocks from the " \
1823 "IndexedFreeList whose size is a multiple of requested size") \
1824 \
1825 product(bool, CMSLoopWarn, false, \
1826 "Warn in case of excessive CMS looping") \
1827 \
1828 /* where does the range max value of (max_jint - 1) come from? */ \
1829 product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
1830 "Maximum size of marking stack") \
1831 range(1, (max_jint - 1)) \
1832 \
1833 product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
1834 "Size of marking stack") \
1835 constraint(MarkStackSizeConstraintFunc,AfterErgo) \
1836 \
1837 notproduct(bool, CMSMarkStackOverflowALot, false, \
1838 "Simulate frequent marking stack / work queue overflow") \
1839 \
1840 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
1841 "An \"interval\" counter that determines how frequently " \
1842 "to simulate overflow; a smaller number increases frequency") \
1843 \
1844 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
1845 "Maximum number of abortable preclean iterations, if > 0") \
1846 \
1847 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
1848 "Maximum time in abortable preclean (in milliseconds)") \
1849 range(0, max_intx) \
1850 \
1851 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
1852 "Nominal minimum work per abortable preclean iteration") \
1853 \
1854 manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
1855 "Time that we sleep between iterations when not given " \
1856 "enough work per iteration") \
1857 range(0, max_intx) \
1858 \
1859 product(size_t, CMSRescanMultiple, 32, \
1860 "Size (in cards) of CMS parallel rescan task") \
1861 range(1, max_uintx) \
1862 \
1863 product(size_t, CMSConcMarkMultiple, 32, \
1864 "Size (in cards) of CMS concurrent MT marking task") \
1865 range(1, max_uintx) \
1866 \
1867 product(bool, CMSAbortSemantics, false, \
1868 "Whether abort-on-overflow semantics is implemented") \
1869 \
1870 product(bool, CMSParallelInitialMarkEnabled, true, \
1871 "Use the parallel initial mark.") \
1872 \
1920 \
1921 product(bool, CMSPrecleanSurvivors1, false, \
1922 "Preclean survivors during (initial) preclean phase") \
1923 \
1924 product(bool, CMSPrecleanSurvivors2, true, \
1925 "Preclean survivors during abortable preclean phase") \
1926 \
1927 product(uintx, CMSPrecleanThreshold, 1000, \
1928 "Do not iterate again if number of dirty cards is less than this")\
1929 range(100, max_uintx) \
1930 \
1931 product(bool, CMSCleanOnEnter, true, \
1932 "Clean-on-enter optimization for reducing number of dirty cards") \
1933 \
1934 product(uintx, CMSRemarkVerifyVariant, 1, \
1935 "Choose variant (1,2) of verification following remark") \
1936 range(1, 2) \
1937 \
1938 product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
1939 "If Eden size is below this, do not try to schedule remark") \
1940 \
1941 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1942 "The Eden occupancy percentage (0-100) at which " \
1943 "to try and schedule remark pause") \
1944 range(0, 100) \
1945 \
1946 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1947 "Start sampling eden top at least before young gen " \
1948 "occupancy reaches 1/<ratio> of the size at which " \
1949 "we plan to schedule remark") \
1950 range(1, max_uintx) \
1951 \
1952 product(uintx, CMSSamplingGrain, 16*K, \
1953 "The minimum distance between eden samples for CMS (see above)") \
1954 range(1, max_uintx) \
1955 \
1956 product(bool, CMSScavengeBeforeRemark, false, \
1957 "Attempt scavenge before the CMS remark step") \
1958 \
1959 develop(bool, CMSTraceSweeper, false, \
1960 "Trace some actions of the CMS sweeper") \
1961 \
1962 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1963 "Don't drain below this size per parallel worker/thief") \
1964 range(1, max_juint) \
1965 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1966 \
1967 manageable(intx, CMSWaitDuration, 2000, \
1968 "Time in milliseconds that CMS thread waits for young GC") \
1969 \
1970 develop(uintx, CMSCheckInterval, 1000, \
1971 "Interval in milliseconds that CMS thread checks if it " \
1972 "should start a collection cycle") \
1973 \
1974 product(bool, CMSYield, true, \
1975 "Yield between steps of CMS") \
1976 \
1977 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1978 "Bitmap operations should process at most this many bits " \
1979 "between yields") \
1980 range(1, max_uintx) \
1981 \
1982 product(bool, CMSDumpAtPromotionFailure, false, \
1983 "Dump useful information about the state of the CMS old " \
1984 "generation upon a promotion failure") \
1985 \
1986 product(bool, CMSPrintChunksInDump, false, \
1987 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1988 "more detailed information about the free chunks") \
2150 product(bool, PrintTLAB, false, \
2151 "Print various TLAB related information") \
2152 \
2153 product(bool, TLABStats, true, \
2154 "Provide more detailed and expensive TLAB statistics " \
2155 "(with PrintTLAB)") \
2156 \
2157 product_pd(bool, NeverActAsServerClassMachine, \
2158 "Never act like a server-class machine") \
2159 \
2160 product(bool, AlwaysActAsServerClassMachine, false, \
2161 "Always act like a server-class machine") \
2162 \
2163 product_pd(uint64_t, MaxRAM, \
2164 "Real memory size (in bytes) used to set maximum heap size") \
2165 range(0, 0XFFFFFFFFFFFFFFFF) \
2166 \
2167 product(size_t, ErgoHeapSizeLimit, 0, \
2168 "Maximum ergonomically set heap size (in bytes); zero means use " \
2169 "MaxRAM / MaxRAMFraction") \
2170 \
2171 product(uintx, MaxRAMFraction, 4, \
2172 "Maximum fraction (1/n) of real memory used for maximum heap " \
2173 "size") \
2174 range(1, max_uintx) \
2175 \
2176 product(uintx, MinRAMFraction, 2, \
2177 "Minimum fraction (1/n) of real memory used for maximum heap " \
2178 "size on systems with small physical memory size") \
2179 range(1, max_uintx) \
2180 \
2181 product(uintx, InitialRAMFraction, 64, \
2182 "Fraction (1/n) of real memory used for initial heap size") \
2183 range(1, max_uintx) \
2184 \
2185 develop(uintx, MaxVirtMemFraction, 2, \
2186 "Maximum fraction (1/n) of virtual memory used for ergonomically "\
2187 "determining maximum heap size") \
2188 \
2189 product(bool, UseAutoGCSelectPolicy, false, \
2190 "Use automatic collection selection policy") \
2191 \
2192 product(uintx, AutoGCSelectPauseMillis, 5000, \
2193 "Automatic GC selection pause threshold in milliseconds") \
2194 \
2195 product(bool, UseAdaptiveSizePolicy, true, \
2196 "Use adaptive generation sizing policies") \
2197 \
2198 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2199 "Use adaptive survivor sizing policies") \
2200 \
2201 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2202 "Use adaptive young-old sizing policies at minor collections") \
2203 \
2204 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2205 "Use adaptive young-old sizing policies at major collections") \
2206 \
2207 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2208 "Include statistics from System.gc() for adaptive size policy") \
2209 \
2210 product(bool, UseAdaptiveGCBoundary, false, \
2211 "Allow young-old boundary to move") \
2212 \
2213 develop(bool, TraceAdaptiveGCBoundary, false, \
2214 "Trace young-old boundary moves") \
2215 \
2216 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2217 "Resize the virtual spaces of the young or old generations") \
2218 range(-1, 1) \
2219 \
2220 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2221 "Policy for changing generation size for throughput goals") \
2222 range(0, 1) \
2223 \
2224 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2225 "Number of steps where heuristics is used before data is used") \
2226 \
2227 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2228 "Number of collections before the adaptive sizing is started") \
2229 \
2230 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2231 "Collection interval for printing information; zero means never") \
2232 \
2233 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2234 "Use adaptive minimum footprint as a goal") \
2235 \
2236 product(uintx, AdaptiveSizePolicyWeight, 10, \
2237 "Weight given to exponential resizing, between 0 and 100") \
2238 range(0, 100) \
2239 \
2240 product(uintx, AdaptiveTimeWeight, 25, \
2241 "Weight given to time in adaptive policy, between 0 and 100") \
2242 range(0, 100) \
2243 \
2244 product(uintx, PausePadding, 1, \
2245 "How much buffer to keep for pause time") \
2246 \
2247 product(uintx, PromotedPadding, 3, \
2248 "How much buffer to keep for promotion failure") \
2249 \
2250 product(uintx, SurvivorPadding, 3, \
2251 "How much buffer to keep for survivor overflow") \
2252 \
2253 product(uintx, ThresholdTolerance, 10, \
2254 "Allowed collection cost difference between generations") \
2255 range(0, 100) \
2256 \
2257 product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
2258 "If collection costs are within margin, reduce both by full " \
2259 "delta") \
2260 \
2261 product(uintx, YoungGenerationSizeIncrement, 20, \
2262 "Adaptive size percentage change in young generation") \
2263 range(0, 100) \
2264 \
2265 product(uintx, YoungGenerationSizeSupplement, 80, \
2266 "Supplement to YoungedGenerationSizeIncrement used at startup") \
2267 range(0, 100) \
2268 \
2269 product(uintx, YoungGenerationSizeSupplementDecay, 8, \
2270 "Decay factor to YoungedGenerationSizeSupplement") \
2271 range(1, max_uintx) \
2272 \
2273 product(uintx, TenuredGenerationSizeIncrement, 20, \
2274 "Adaptive size percentage change in tenured generation") \
2275 range(0, 100) \
2276 \
2277 product(uintx, TenuredGenerationSizeSupplement, 80, \
2278 "Supplement to TenuredGenerationSizeIncrement used at startup") \
2279 range(0, 100) \
2280 \
2281 product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
2282 "Decay factor to TenuredGenerationSizeIncrement") \
2283 range(1, max_uintx) \
2284 \
2285 product(uintx, MaxGCPauseMillis, max_uintx, \
2286 "Adaptive size policy maximum GC pause time goal in millisecond, "\
2287 "or (G1 Only) the maximum GC time per MMU time slice") \
2288 range(1, max_uintx) \
2289 constraint(MaxGCPauseMillisConstraintFunc,AfterMemoryInit) \
2290 \
2291 product(uintx, GCPauseIntervalMillis, 0, \
2292 "Time slice for MMU specification") \
2293 constraint(GCPauseIntervalMillisConstraintFunc,AfterMemoryInit) \
2294 \
2295 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
2296 "Adaptive size policy maximum GC minor pause time goal " \
2297 "in millisecond") \
2298 \
2299 product(uintx, GCTimeRatio, 99, \
2300 "Adaptive size policy application time to GC time ratio") \
2301 \
2302 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
2303 "Adaptive size scale down factor for shrinking") \
2304 range(1, max_uintx) \
2305 \
2306 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
2307 "Adaptive size decays the major cost for long major intervals") \
2308 \
2309 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
2310 "Time scale over which major costs decay") \
2311 \
2312 product(uintx, MinSurvivorRatio, 3, \
2313 "Minimum ratio of young generation/survivor space size") \
2314 range(3, max_uintx) \
2315 \
2316 product(uintx, InitialSurvivorRatio, 8, \
2317 "Initial ratio of young generation/survivor space size") \
2318 \
2319 product(size_t, BaseFootPrintEstimate, 256*M, \
2320 "Estimate of footprint other than Java Heap") \
2321 \
2322 product(bool, UseGCOverheadLimit, true, \
2323 "Use policy to limit of proportion of time spent in GC " \
2324 "before an OutOfMemory error is thrown") \
2325 \
2326 product(uintx, GCTimeLimit, 98, \
2327 "Limit of the proportion of time spent in GC before " \
2328 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2329 range(0, 100) \
2330 \
2331 product(uintx, GCHeapFreeLimit, 2, \
2332 "Minimum percentage of free space after a full GC before an " \
2333 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2334 range(0, 100) \
2335 \
2336 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2337 "Number of consecutive collections before gc time limit fires") \
2338 range(1, max_uintx) \
2339 \
2340 product(bool, PrintAdaptiveSizePolicy, false, \
2341 "Print information about AdaptiveSizePolicy") \
2342 \
2343 product(intx, PrefetchCopyIntervalInBytes, -1, \
2344 "How far ahead to prefetch destination area (<= 0 means off)") \
2345 \
2346 product(intx, PrefetchScanIntervalInBytes, -1, \
2347 "How far ahead to prefetch scan area (<= 0 means off)") \
2348 \
2349 product(intx, PrefetchFieldsAhead, -1, \
2350 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2351 \
2352 diagnostic(bool, VerifySilently, false, \
2353 "Do not print the verification progress") \
2354 \
2355 diagnostic(bool, VerifyDuringStartup, false, \
2356 "Verify memory system before executing any Java code " \
2357 "during VM initialization") \
2358 \
2359 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2360 "Verify system before exiting") \
2361 \
2362 diagnostic(bool, VerifyBeforeGC, false, \
2363 "Verify memory system before GC") \
2364 \
2365 diagnostic(bool, VerifyAfterGC, false, \
2366 "Verify memory system after GC") \
2367 \
2368 diagnostic(bool, VerifyDuringGC, false, \
2369 "Verify memory system during GC (between phases)") \
2370 \
2378 product(bool, UseCondCardMark, false, \
2379 "Check for already marked card before updating card table") \
2380 \
2381 diagnostic(bool, VerifyRememberedSets, false, \
2382 "Verify GC remembered sets") \
2383 \
2384 diagnostic(bool, VerifyObjectStartArray, true, \
2385 "Verify GC object start array if verify before/after") \
2386 \
2387 product(bool, DisableExplicitGC, false, \
2388 "Ignore calls to System.gc()") \
2389 \
2390 notproduct(bool, CheckMemoryInitialization, false, \
2391 "Check memory initialization") \
2392 \
2393 diagnostic(bool, BindCMSThreadToCPU, false, \
2394 "Bind CMS Thread to CPU if possible") \
2395 \
2396 diagnostic(uintx, CPUForCMSThread, 0, \
2397 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2398 \
2399 product(bool, BindGCTaskThreadsToCPUs, false, \
2400 "Bind GCTaskThreads to CPUs if possible") \
2401 \
2402 product(bool, UseGCTaskAffinity, false, \
2403 "Use worker affinity when asking for GCTasks") \
2404 \
2405 product(uintx, ProcessDistributionStride, 4, \
2406 "Stride through processors when distributing processes") \
2407 \
2408 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2409 "Number of times the coordinator GC thread will sleep while " \
2410 "yielding before giving up and resuming GC") \
2411 \
2412 product(uintx, CMSYieldSleepCount, 0, \
2413 "Number of times a GC thread (minus the coordinator) " \
2414 "will sleep while yielding before giving up and resuming GC") \
2415 \
2416 /* gc tracing */ \
2417 manageable(bool, PrintGC, false, \
2418 "Print message at garbage collection") \
2419 \
2420 manageable(bool, PrintGCDetails, false, \
2421 "Print more details at garbage collection") \
2422 \
2423 manageable(bool, PrintGCDateStamps, false, \
2424 "Print date stamps at garbage collection") \
2425 \
2426 manageable(bool, PrintGCTimeStamps, false, \
2427 "Print timestamps at garbage collection") \
2428 \
2429 manageable(bool, PrintGCID, true, \
2430 "Print an identifier for each garbage collection") \
2431 \
2432 product(bool, PrintGCTaskTimeStamps, false, \
2433 "Print timestamps for individual gc worker thread tasks") \
2434 \
2543 "Suppress workaround for libthread GP fault") \
2544 \
2545 product(bool, PrintJNIGCStalls, false, \
2546 "Print diagnostic message when GC is stalled " \
2547 "by JNI critical section") \
2548 \
2549 experimental(double, ObjectCountCutOffPercent, 0.5, \
2550 "The percentage of the used heap that the instances of a class " \
2551 "must occupy for the class to generate a trace event") \
2552 range(0.0, 100.0) \
2553 \
2554 /* GC log rotation setting */ \
2555 \
2556 product(bool, UseGCLogFileRotation, false, \
2557 "Rotate gclog files (for long running applications). It requires "\
2558 "-Xloggc:<filename>") \
2559 \
2560 product(uintx, NumberOfGCLogFiles, 0, \
2561 "Number of gclog files in rotation " \
2562 "(default: 0, no rotation)") \
2563 \
2564 product(size_t, GCLogFileSize, 8*K, \
2565 "GC log file size, requires UseGCLogFileRotation. " \
2566 "Set to 0 to only trigger rotation via jcmd") \
2567 \
2568 /* JVMTI heap profiling */ \
2569 \
2570 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2571 "Trace JVMTI object tagging calls") \
2572 \
2573 diagnostic(bool, VerifyBeforeIteration, false, \
2574 "Verify memory system before JVMTI iteration") \
2575 \
2576 /* compiler interface */ \
2577 \
2578 develop(bool, CIPrintCompilerName, false, \
2579 "when CIPrint is active, print the name of the active compiler") \
2580 \
2581 diagnostic(bool, CIPrintCompileQueue, false, \
2582 "display the contents of the compile queue whenever a " \
2583 "compilation is enqueued") \
2584 \
2585 develop(bool, CIPrintRequests, false, \
2586 "display every request for compilation") \
3314 \
3315 develop(intx, InlineThrowMaxSize, 200, \
3316 "Force inlining of throwing methods smaller than this") \
3317 range(0, max_jint) \
3318 \
3319 develop(intx, ProfilerNodeSize, 1024, \
3320 "Size in K to allocate for the Profile Nodes of each thread") \
3321 range(0, 1024) \
3322 \
3323 /* gc parameters */ \
3324 product(size_t, InitialHeapSize, 0, \
3325 "Initial heap size (in bytes); zero means use ergonomics") \
3326 constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
3327 \
3328 product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
3329 "Maximum heap size (in bytes)") \
3330 constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
3331 \
3332 product(size_t, OldSize, ScaleForWordSize(4*M), \
3333 "Initial tenured generation size (in bytes)") \
3334 \
3335 product(size_t, NewSize, ScaleForWordSize(1*M), \
3336 "Initial new generation size (in bytes)") \
3337 constraint(NewSizeConstraintFunc,AfterErgo) \
3338 \
3339 product(size_t, MaxNewSize, max_uintx, \
3340 "Maximum new generation size (in bytes), max_uintx means set " \
3341 "ergonomically") \
3342 \
3343 product(size_t, PretenureSizeThreshold, 0, \
3344 "Maximum size in bytes of objects allocated in DefNew " \
3345 "generation; zero means no maximum") \
3346 \
3347 product(size_t, MinTLABSize, 2*K, \
3348 "Minimum allowed TLAB size (in bytes)") \
3349 range(1, max_uintx) \
3350 constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
3351 \
3352 product(size_t, TLABSize, 0, \
3353 "Starting TLAB size (in bytes); zero means set ergonomically") \
3354 constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
3355 \
3356 product(size_t, YoungPLABSize, 4096, \
3357 "Size of young gen promotion LAB's (in HeapWords)") \
3358 constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
3359 \
3360 product(size_t, OldPLABSize, 1024, \
3361 "Size of old gen promotion LAB's (in HeapWords), or Number " \
3362 "of blocks to attempt to claim when refilling CMS LAB's") \
3363 constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
3364 \
3365 product(uintx, TLABAllocationWeight, 35, \
3366 "Allocation averaging weight") \
3367 range(0, 100) \
3368 \
3369 /* Limit the lower bound of this flag to 1 as it is used */ \
3370 /* in a division expression. */ \
3371 product(uintx, TLABWasteTargetPercent, 1, \
3372 "Percentage of Eden that can be wasted") \
3373 range(1, 100) \
3374 \
3375 product(uintx, TLABRefillWasteFraction, 64, \
3376 "Maximum TLAB waste at a refill (internal fragmentation)") \
3377 range(1, max_uintx) \
3378 \
3379 product(uintx, TLABWasteIncrement, 4, \
3380 "Increment allowed waste at slow allocation") \
3381 \
3382 product(uintx, SurvivorRatio, 8, \
3383 "Ratio of eden/survivor space size") \
3384 range(1, max_uintx-2) \
3385 constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
3386 \
3387 product(uintx, NewRatio, 2, \
3388 "Ratio of old/new generation sizes") \
3389 range(0, max_uintx-1) \
3390 \
3391 product_pd(size_t, NewSizeThreadIncrease, \
3392 "Additional size added to desired new generation size per " \
3393 "non-daemon thread (in bytes)") \
3394 \
3395 product_pd(size_t, MetaspaceSize, \
3396 "Initial size of Metaspaces (in bytes)") \
3397 constraint(MetaspaceSizeConstraintFunc,AfterErgo) \
3398 \
3399 product(size_t, MaxMetaspaceSize, max_uintx, \
3400 "Maximum size of Metaspaces (in bytes)") \
3401 constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo) \
3402 \
3403 product(size_t, CompressedClassSpaceSize, 1*G, \
3404 "Maximum size of class area in Metaspace when compressed " \
3405 "class pointers are used") \
3406 range(1*M, 3*G) \
3407 \
3408 manageable(uintx, MinHeapFreeRatio, 40, \
3409 "The minimum percentage of heap free after GC to avoid expansion."\
3410 " For most GCs this applies to the old generation. In G1 and" \
3411 " ParallelGC it applies to the whole heap.") \
3412 range(0, 100) \
3413 constraint(MinHeapFreeRatioConstraintFunc,AfterErgo) \
3414 \
3415 manageable(uintx, MaxHeapFreeRatio, 70, \
3416 "The maximum percentage of heap free after GC to avoid shrinking."\
3417 " For most GCs this applies to the old generation. In G1 and" \
3418 " ParallelGC it applies to the whole heap.") \
3419 range(0, 100) \
3420 constraint(MaxHeapFreeRatioConstraintFunc,AfterErgo) \
3421 \
3422 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
3423 "Number of milliseconds per MB of free space in the heap") \
3424 range(0, max_intx) \
3425 constraint(SoftRefLRUPolicyMSPerMBConstraintFunc,AfterMemoryInit) \
3426 \
3427 product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
3428 "The minimum change in heap space due to GC (in bytes)") \
3429 \
3430 product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
3431 "The minimum expansion of Metaspace (in bytes)") \
3432 \
3433 product(uintx, MaxMetaspaceFreeRatio, 70, \
3434 "The maximum percentage of Metaspace free after GC to avoid " \
3435 "shrinking") \
3436 range(0, 100) \
3437 constraint(MaxMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3438 \
3439 product(uintx, MinMetaspaceFreeRatio, 40, \
3440 "The minimum percentage of Metaspace free after GC to avoid " \
3441 "expansion") \
3442 range(0, 99) \
3443 constraint(MinMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3444 \
3445 product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
3446 "The maximum expansion of Metaspace without full GC (in bytes)") \
3447 \
3448 product(uintx, QueuedAllocationWarningCount, 0, \
3449 "Number of times an allocation that queues behind a GC " \
3450 "will retry before printing a warning") \
3451 \
3452 diagnostic(uintx, VerifyGCStartAt, 0, \
3453 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
3454 \
3455 diagnostic(intx, VerifyGCLevel, 0, \
3456 "Generation level at which to start +VerifyBefore/AfterGC") \
3457 range(0, 1) \
3458 \
3459 product(uintx, MaxTenuringThreshold, 15, \
3460 "Maximum value for tenuring threshold") \
3461 range(0, markOopDesc::max_age + 1) \
3462 constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
3463 \
3464 product(uintx, InitialTenuringThreshold, 7, \
3465 "Initial value for tenuring threshold") \
3466 range(0, markOopDesc::max_age + 1) \
3467 constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
3468 \
3469 product(uintx, TargetSurvivorRatio, 50, \
3470 "Desired percentage of survivor space used after scavenge") \
3471 range(0, 100) \
3472 \
3473 product(uintx, MarkSweepDeadRatio, 5, \
3474 "Percentage (0-100) of the old gen allowed as dead wood. " \
3475 "Serial mark sweep treats this as both the minimum and maximum " \
3476 "value. " \
3477 "CMS uses this value only if it falls back to mark sweep. " \
3478 "Par compact uses a variable scale based on the density of the " \
3479 "generation and treats this as the maximum value when the heap " \
3480 "is either completely full or completely empty. Par compact " \
3481 "also has a smaller default value; see arguments.cpp.") \
3482 range(0, 100) \
3483 \
3484 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3485 "How often should we fully compact the heap (ignoring the dead " \
3486 "space parameters)") \
3487 range(1, max_uintx) \
3488 \
3489 product(intx, PrintCMSStatistics, 0, \
3490 "Statistics for CMS") \
3491 \
3492 product(bool, PrintCMSInitiationStatistics, false, \
3493 "Statistics for initiating a CMS collection") \
3494 \
3495 product(intx, PrintFLSStatistics, 0, \
3496 "Statistics for CMS' FreeListSpace") \
3497 \
3498 product(intx, PrintFLSCensus, 0, \
3499 "Census for CMS' FreeListSpace") \
3500 \
3501 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3502 "Delay between expansion and allocation (in milliseconds)") \
3503 \
3504 develop(uintx, GCWorkerDelayMillis, 0, \
3505 "Delay in scheduling GC workers (in milliseconds)") \
3506 \
3507 product(intx, DeferThrSuspendLoopCount, 4000, \
3508 "(Unstable) Number of times to iterate in safepoint loop " \
3509 "before blocking VM threads ") \
3510 range(-1, max_jint-1) \
3511 \
3512 product(intx, DeferPollingPageLoopCount, -1, \
3513 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3514 "before changing safepoint polling page to RO ") \
3515 range(-1, max_jint-1) \
3516 \
3517 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3518 range(0, max_intx) \
3519 \
3520 product(bool, PSChunkLargeArrays, true, \
3521 "Process large arrays in chunks") \
3522 \
3523 product(uintx, GCDrainStackTargetSize, 64, \
3524 "Number of entries we will try to leave on the stack " \
3525 "during parallel gc") \
3526 \
3527 /* stack parameters */ \
3528 product_pd(intx, StackYellowPages, \
3529 "Number of yellow zone (recoverable overflows) pages") \
3530 range(MIN_STACK_YELLOW_PAGES, (DEFAULT_STACK_YELLOW_PAGES+5)) \
3531 \
3532 product_pd(intx, StackRedPages, \
3533 "Number of red zone (unrecoverable overflows) pages") \
3534 range(MIN_STACK_RED_PAGES, (DEFAULT_STACK_RED_PAGES+2)) \
3535 \
3536 /* greater stack shadow pages can't generate instruction to bang stack */ \
3537 product_pd(intx, StackShadowPages, \
3538 "Number of shadow zone (for overflow checking) pages " \
3539 "this should exceed the depth of the VM and native call stack") \
3540 range(MIN_STACK_SHADOW_PAGES, (DEFAULT_STACK_SHADOW_PAGES+30)) \
3541 \
3542 product_pd(intx, ThreadStackSize, \
3543 "Thread Stack Size (in Kbytes)") \
3544 range(0, max_intx-os::vm_page_size()) \
3545 \
|
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_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
609 //
610 // constraint is a macro that will expand to custom function call
611 // for constraint checking if provided - see commandLineFlagConstraintList.hpp
612 //
613
614 #define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product, range, constraint) \
615 \
616 lp64_product(bool, UseCompressedOops, false, \
617 "Use 32-bit object references in 64-bit VM. " \
618 "lp64_product means flag is always constant in 32 bit VM") \
619 \
620 lp64_product(bool, UseCompressedClassPointers, false, \
621 "Use 32-bit class pointers in 64-bit VM. " \
622 "lp64_product means flag is always constant in 32 bit VM") \
623 \
624 notproduct(bool, CheckCompressedOops, true, \
625 "Generate checks in encoding/decoding code in debug VM") \
626 \
627 product_pd(size_t, HeapBaseMinAddress, \
628 "OS specific low limit for heap base address") \
629 constraint(HeapBaseMinAddressConstraintFunc,AfterErgo) \
630 \
631 product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \
632 "Heap allocation steps through preferred address regions to find" \
633 " where it can allocate the heap. Number of steps to take per " \
634 "region.") \
635 range(1, max_uintx) \
636 \
637 diagnostic(bool, PrintCompressedOopsMode, false, \
638 "Print compressed oops base address and encoding mode") \
639 \
640 lp64_product(intx, ObjectAlignmentInBytes, 8, \
641 "Default object alignment in bytes, 8 is minimum") \
642 range(8, 256) \
643 constraint(ObjectAlignmentInBytesConstraintFunc,AtParse) \
644 \
645 product(bool, AssumeMP, false, \
646 "Instruct the VM to assume multiple processors are available") \
647 \
648 /* UseMembar is theoretically a temp flag used for memory barrier */ \
649 /* removal testing. It was supposed to be removed before FCS but has */ \
675 "Allocate large pages individually for better affinity") \
676 \
677 develop(bool, LargePagesIndividualAllocationInjectError, false, \
678 "Fail large pages individual allocation") \
679 \
680 product(bool, UseLargePagesInMetaspace, false, \
681 "Use large page memory in metaspace. " \
682 "Only used if UseLargePages is enabled.") \
683 \
684 develop(bool, TracePageSizes, false, \
685 "Trace page size selection and usage") \
686 \
687 product(bool, UseNUMA, false, \
688 "Use NUMA if available") \
689 \
690 product(bool, UseNUMAInterleaving, false, \
691 "Interleave memory across NUMA nodes if available") \
692 \
693 product(size_t, NUMAInterleaveGranularity, 2*M, \
694 "Granularity to use for NUMA interleaving on Windows OS") \
695 range(os::vm_allocation_granularity(), max_uintx) \
696 constraint(NUMAInterleaveGranularityConstraintFunc,AfterErgo) \
697 \
698 product(bool, ForceNUMA, false, \
699 "Force NUMA optimizations on single-node/UMA systems") \
700 \
701 product(uintx, NUMAChunkResizeWeight, 20, \
702 "Percentage (0-100) used to weight the current sample when " \
703 "computing exponentially decaying average for " \
704 "AdaptiveNUMAChunkSizing") \
705 range(0, 100) \
706 \
707 product(size_t, NUMASpaceResizeRate, 1*G, \
708 "Do not reallocate more than this amount per collection") \
709 range(0, max_uintx) \
710 \
711 product(bool, UseAdaptiveNUMAChunkSizing, true, \
712 "Enable adaptive chunk sizing for NUMA") \
713 \
714 product(bool, NUMAStats, false, \
715 "Print NUMA stats in detailed heap information") \
716 \
717 product(uintx, NUMAPageScanRate, 256, \
718 "Maximum number of pages to include in the page scan procedure") \
719 range(0, max_uintx) \
720 \
721 product_pd(bool, NeedsDeoptSuspend, \
722 "True for register window machines (sparc/ia64)") \
723 \
724 product(intx, UseSSE, 99, \
725 "Highest supported SSE instructions set on x86/x64") \
726 range(0, 99) \
727 \
728 product(bool, UseAES, false, \
729 "Control whether AES instructions can be used on x86/x64") \
730 \
731 product(bool, UseSHA, false, \
732 "Control whether SHA instructions can be used " \
733 "on SPARC and on ARM") \
734 \
735 product(bool, UseGHASHIntrinsics, false, \
736 "Use intrinsics for GHASH versions of crypto") \
737 \
738 product(size_t, LargePageSizeInBytes, 0, \
739 "Large page size (0 to let VM choose the page size)") \
740 range(0, max_uintx) \
741 \
742 product(size_t, LargePageHeapSizeThreshold, 128*M, \
743 "Use large pages if maximum heap is at least this big") \
744 range(0, max_uintx) \
745 \
746 product(bool, ForceTimeHighResolution, false, \
747 "Using high time resolution (for Win32 only)") \
748 \
749 develop(bool, TraceItables, false, \
750 "Trace initialization and use of itables") \
751 \
752 develop(bool, TracePcPatching, false, \
753 "Trace usage of frame::patch_pc") \
754 \
755 develop(bool, TraceJumps, false, \
756 "Trace assembly jumps in thread ring buffer") \
757 \
758 develop(bool, TraceRelocator, false, \
759 "Trace the bytecode relocator") \
760 \
761 develop(bool, TraceLongCompiles, false, \
762 "Print out every time compilation is longer than " \
763 "a given threshold") \
764 \
1521 product(bool, TraceMonitorInflation, false, \
1522 "Trace monitor inflation in JVM") \
1523 \
1524 /* gc */ \
1525 \
1526 product(bool, UseSerialGC, false, \
1527 "Use the Serial garbage collector") \
1528 \
1529 product(bool, UseG1GC, false, \
1530 "Use the Garbage-First garbage collector") \
1531 \
1532 product(bool, UseParallelGC, false, \
1533 "Use the Parallel Scavenge garbage collector") \
1534 \
1535 product(bool, UseParallelOldGC, false, \
1536 "Use the Parallel Old garbage collector") \
1537 \
1538 product(uintx, HeapMaximumCompactionInterval, 20, \
1539 "How often should we maximally compact the heap (not allowing " \
1540 "any dead space)") \
1541 range(0, max_uintx) \
1542 \
1543 product(uintx, HeapFirstMaximumCompactionCount, 3, \
1544 "The collection count for the first maximum compaction") \
1545 range(0, max_uintx) \
1546 \
1547 product(bool, UseMaximumCompactionOnSystemGC, true, \
1548 "Use maximum compaction in the Parallel Old garbage collector " \
1549 "for a system GC") \
1550 \
1551 product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
1552 "The mean used by the parallel compact dead wood " \
1553 "limiter (a number between 0-100)") \
1554 range(0, 100) \
1555 \
1556 product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
1557 "The standard deviation used by the parallel compact dead wood " \
1558 "limiter (a number between 0-100)") \
1559 range(0, 100) \
1560 \
1561 product(uint, ParallelGCThreads, 0, \
1562 "Number of parallel threads parallel gc will use") \
1563 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1564 \
1565 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1607 "A System.gc() request invokes a concurrent collection; " \
1608 "(effective only when using concurrent collectors)") \
1609 \
1610 product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
1611 "A System.gc() request invokes a concurrent collection and " \
1612 "also unloads classes during such a concurrent gc cycle " \
1613 "(effective only when UseConcMarkSweepGC)") \
1614 \
1615 product(bool, GCLockerInvokesConcurrent, false, \
1616 "The exit of a JNI critical section necessitating a scavenge, " \
1617 "also kicks off a background concurrent collection") \
1618 \
1619 product(uintx, GCLockerEdenExpansionPercent, 5, \
1620 "How much the GC can expand the eden by while the GC locker " \
1621 "is active (as a percentage)") \
1622 range(0, 100) \
1623 \
1624 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1625 "Number of times to retry allocations when " \
1626 "blocked by the GC locker") \
1627 range(0, max_uintx) \
1628 \
1629 product(bool, UseCMSBestFit, true, \
1630 "Use CMS best fit allocation strategy") \
1631 \
1632 product(bool, UseParNewGC, false, \
1633 "Use parallel threads in the new generation") \
1634 \
1635 product(bool, PrintTaskqueue, false, \
1636 "Print taskqueue statistics for parallel collectors") \
1637 \
1638 product(bool, PrintTerminationStats, false, \
1639 "Print termination statistics for parallel collectors") \
1640 \
1641 product(uintx, ParallelGCBufferWastePct, 10, \
1642 "Wasted fraction of parallel allocation buffer") \
1643 range(0, 100) \
1644 \
1645 product(uintx, TargetPLABWastePct, 10, \
1646 "Target wasted space in last buffer as percent of overall " \
1647 "allocation") \
1662 "Scan a subset of object array and push remainder, if array is " \
1663 "bigger than this") \
1664 range(1, max_intx) \
1665 \
1666 product(bool, ParGCUseLocalOverflow, false, \
1667 "Instead of a global overflow list, use local overflow stacks") \
1668 \
1669 product(bool, ParGCTrimOverflow, true, \
1670 "Eagerly trim the local overflow lists " \
1671 "(when ParGCUseLocalOverflow)") \
1672 \
1673 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1674 "Simulate work queue overflow in ParNew") \
1675 \
1676 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1677 "An `interval' counter that determines how frequently " \
1678 "we simulate overflow; a smaller number increases frequency") \
1679 \
1680 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1681 "The desired number of objects to claim from the overflow list") \
1682 range(0, max_uintx) \
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") \
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 range(1, max_uintx) \
1737 \
1738 product(bool, AlwaysPreTouch, false, \
1739 "Force all freshly committed pages to be pre-touched") \
1740 \
1741 product_pd(size_t, CMSYoungGenPerWorker, \
1742 "The maximum size of young gen chosen by default per GC worker " \
1743 "thread available") \
1744 range(1, max_uintx) \
1745 \
1746 product(uintx, CMSIncrementalSafetyFactor, 10, \
1747 "Percentage (0-100) used to add conservatism when computing the " \
1748 "duty cycle") \
1749 range(0, 100) \
1750 \
1751 product(uintx, CMSExpAvgFactor, 50, \
1752 "Percentage (0-100) used to weight the current sample when " \
1753 "computing exponential averages for CMS statistics") \
1754 range(0, 100) \
1755 \
1756 product(uintx, CMS_FLSWeight, 75, \
1757 "Percentage (0-100) used to weight the current sample when " \
1758 "computing exponentially decaying averages for CMS FLS " \
1759 "statistics") \
1760 range(0, 100) \
1761 \
1762 product(uintx, CMS_FLSPadding, 1, \
1763 "The multiple of deviation from mean to use for buffering " \
1764 "against volatility in free list demand") \
1765 range(0, max_juint) \
1766 \
1767 product(uintx, FLSCoalescePolicy, 2, \
1768 "CMS: aggressiveness level for coalescing, increasing " \
1769 "from 0 to 4") \
1770 range(0, 4) \
1771 \
1772 product(bool, FLSAlwaysCoalesceLarge, false, \
1773 "CMS: larger free blocks are always available for coalescing") \
1774 \
1775 product(double, FLSLargestBlockCoalesceProximity, 0.99, \
1776 "CMS: the smaller the percentage the greater the coalescing " \
1777 "force") \
1778 range(0.0, 1.0) \
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 range(0.0, DBL_MAX) \
1784 \
1785 product(double, CMSLargeCoalSurplusPercent, 0.95, \
1794 range(0.0, DBL_MAX) \
1795 \
1796 product(double, CMSLargeSplitSurplusPercent, 1.00, \
1797 "CMS: the factor by which to inflate estimated demand of large " \
1798 "block sizes to prevent splitting to supply demand for smaller " \
1799 "blocks") \
1800 range(0.0, DBL_MAX) \
1801 \
1802 product(bool, CMSExtrapolateSweep, false, \
1803 "CMS: cushion for block demand during sweep") \
1804 \
1805 product(uintx, CMS_SweepWeight, 75, \
1806 "Percentage (0-100) used to weight the current sample when " \
1807 "computing exponentially decaying average for inter-sweep " \
1808 "duration") \
1809 range(0, 100) \
1810 \
1811 product(uintx, CMS_SweepPadding, 1, \
1812 "The multiple of deviation from mean to use for buffering " \
1813 "against volatility in inter-sweep duration") \
1814 range(0, max_juint) \
1815 \
1816 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
1817 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
1818 "duration exceeds this threshold in milliseconds") \
1819 range(0, max_uintx) \
1820 \
1821 product(bool, CMSClassUnloadingEnabled, true, \
1822 "Whether class unloading enabled when using CMS GC") \
1823 \
1824 product(uintx, CMSClassUnloadingMaxInterval, 0, \
1825 "When CMS class unloading is enabled, the maximum CMS cycle " \
1826 "count for which classes may not be unloaded") \
1827 range(0, max_uintx) \
1828 \
1829 product(uintx, CMSIndexedFreeListReplenish, 4, \
1830 "Replenish an indexed free list with this number of chunks") \
1831 range(1, max_uintx) \
1832 \
1833 product(bool, CMSReplenishIntermediate, true, \
1834 "Replenish all intermediate free-list caches") \
1835 \
1836 product(bool, CMSSplitIndexedFreeListBlocks, true, \
1837 "When satisfying batched demand, split blocks from the " \
1838 "IndexedFreeList whose size is a multiple of requested size") \
1839 \
1840 product(bool, CMSLoopWarn, false, \
1841 "Warn in case of excessive CMS looping") \
1842 \
1843 /* where does the range max value of (max_jint - 1) come from? */ \
1844 product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
1845 "Maximum size of marking stack") \
1846 range(1, (max_jint - 1)) \
1847 \
1848 product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
1849 "Size of marking stack") \
1850 constraint(MarkStackSizeConstraintFunc,AfterErgo) \
1851 \
1852 notproduct(bool, CMSMarkStackOverflowALot, false, \
1853 "Simulate frequent marking stack / work queue overflow") \
1854 \
1855 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
1856 "An \"interval\" counter that determines how frequently " \
1857 "to simulate overflow; a smaller number increases frequency") \
1858 \
1859 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
1860 "Maximum number of abortable preclean iterations, if > 0") \
1861 range(0, max_uintx) \
1862 \
1863 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
1864 "Maximum time in abortable preclean (in milliseconds)") \
1865 range(0, max_intx) \
1866 \
1867 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
1868 "Nominal minimum work per abortable preclean iteration") \
1869 range(0, max_uintx) \
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 \
1937 \
1938 product(bool, CMSPrecleanSurvivors1, false, \
1939 "Preclean survivors during (initial) preclean phase") \
1940 \
1941 product(bool, CMSPrecleanSurvivors2, true, \
1942 "Preclean survivors during abortable preclean phase") \
1943 \
1944 product(uintx, CMSPrecleanThreshold, 1000, \
1945 "Do not iterate again if number of dirty cards is less than this")\
1946 range(100, max_uintx) \
1947 \
1948 product(bool, CMSCleanOnEnter, true, \
1949 "Clean-on-enter optimization for reducing number of dirty cards") \
1950 \
1951 product(uintx, CMSRemarkVerifyVariant, 1, \
1952 "Choose variant (1,2) of verification following remark") \
1953 range(1, 2) \
1954 \
1955 product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
1956 "If Eden size is below this, do not try to schedule remark") \
1957 range(0, max_uintx) \
1958 \
1959 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1960 "The Eden occupancy percentage (0-100) at which " \
1961 "to try and schedule remark pause") \
1962 range(0, 100) \
1963 \
1964 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1965 "Start sampling eden top at least before young gen " \
1966 "occupancy reaches 1/<ratio> of the size at which " \
1967 "we plan to schedule remark") \
1968 range(1, max_uintx) \
1969 \
1970 product(uintx, CMSSamplingGrain, 16*K, \
1971 "The minimum distance between eden samples for CMS (see above)") \
1972 range(1, max_uintx) \
1973 \
1974 product(bool, CMSScavengeBeforeRemark, false, \
1975 "Attempt scavenge before the CMS remark step") \
1976 \
1977 develop(bool, CMSTraceSweeper, false, \
1978 "Trace some actions of the CMS sweeper") \
1979 \
1980 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1981 "Don't drain below this size per parallel worker/thief") \
1982 range(1, max_juint) \
1983 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1984 \
1985 manageable(intx, CMSWaitDuration, 2000, \
1986 "Time in milliseconds that CMS thread waits for young GC") \
1987 range(min_jint, max_jint) \
1988 \
1989 develop(uintx, CMSCheckInterval, 1000, \
1990 "Interval in milliseconds that CMS thread checks if it " \
1991 "should start a collection cycle") \
1992 \
1993 product(bool, CMSYield, true, \
1994 "Yield between steps of CMS") \
1995 \
1996 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1997 "Bitmap operations should process at most this many bits " \
1998 "between yields") \
1999 range(1, max_uintx) \
2000 \
2001 product(bool, CMSDumpAtPromotionFailure, false, \
2002 "Dump useful information about the state of the CMS old " \
2003 "generation upon a promotion failure") \
2004 \
2005 product(bool, CMSPrintChunksInDump, false, \
2006 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
2007 "more detailed information about the free chunks") \
2169 product(bool, PrintTLAB, false, \
2170 "Print various TLAB related information") \
2171 \
2172 product(bool, TLABStats, true, \
2173 "Provide more detailed and expensive TLAB statistics " \
2174 "(with PrintTLAB)") \
2175 \
2176 product_pd(bool, NeverActAsServerClassMachine, \
2177 "Never act like a server-class machine") \
2178 \
2179 product(bool, AlwaysActAsServerClassMachine, false, \
2180 "Always act like a server-class machine") \
2181 \
2182 product_pd(uint64_t, MaxRAM, \
2183 "Real memory size (in bytes) used to set maximum heap size") \
2184 range(0, 0XFFFFFFFFFFFFFFFF) \
2185 \
2186 product(size_t, ErgoHeapSizeLimit, 0, \
2187 "Maximum ergonomically set heap size (in bytes); zero means use " \
2188 "MaxRAM / MaxRAMFraction") \
2189 range(0, max_uintx) \
2190 \
2191 product(uintx, MaxRAMFraction, 4, \
2192 "Maximum fraction (1/n) of real memory used for maximum heap " \
2193 "size") \
2194 range(1, max_uintx) \
2195 \
2196 product(uintx, MinRAMFraction, 2, \
2197 "Minimum fraction (1/n) of real memory used for maximum heap " \
2198 "size on systems with small physical memory size") \
2199 range(1, max_uintx) \
2200 \
2201 product(uintx, InitialRAMFraction, 64, \
2202 "Fraction (1/n) of real memory used for initial heap size") \
2203 range(1, max_uintx) \
2204 \
2205 develop(uintx, MaxVirtMemFraction, 2, \
2206 "Maximum fraction (1/n) of virtual memory used for ergonomically "\
2207 "determining maximum heap size") \
2208 \
2209 product(bool, UseAutoGCSelectPolicy, false, \
2210 "Use automatic collection selection policy") \
2211 \
2212 product(uintx, AutoGCSelectPauseMillis, 5000, \
2213 "Automatic GC selection pause threshold in milliseconds") \
2214 range(0, max_uintx) \
2215 \
2216 product(bool, UseAdaptiveSizePolicy, true, \
2217 "Use adaptive generation sizing policies") \
2218 \
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 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2246 "Number of steps where heuristics is used before data is used") \
2247 range(0, max_uintx) \
2248 \
2249 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2250 "Number of collections before the adaptive sizing is started") \
2251 \
2252 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2253 "Collection interval for printing information; zero means never") \
2254 range(0, max_uintx) \
2255 \
2256 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2257 "Use adaptive minimum footprint as a goal") \
2258 \
2259 product(uintx, AdaptiveSizePolicyWeight, 10, \
2260 "Weight given to exponential resizing, between 0 and 100") \
2261 range(0, 100) \
2262 \
2263 product(uintx, AdaptiveTimeWeight, 25, \
2264 "Weight given to time in adaptive policy, between 0 and 100") \
2265 range(0, 100) \
2266 \
2267 product(uintx, PausePadding, 1, \
2268 "How much buffer to keep for pause time") \
2269 range(0, max_juint) \
2270 \
2271 product(uintx, PromotedPadding, 3, \
2272 "How much buffer to keep for promotion failure") \
2273 range(0, max_juint) \
2274 \
2275 product(uintx, SurvivorPadding, 3, \
2276 "How much buffer to keep for survivor overflow") \
2277 range(0, max_juint) \
2278 \
2279 product(uintx, ThresholdTolerance, 10, \
2280 "Allowed collection cost difference between generations") \
2281 range(0, 100) \
2282 \
2283 product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
2284 "If collection costs are within margin, reduce both by full " \
2285 "delta") \
2286 range(0, 100) \
2287 \
2288 product(uintx, YoungGenerationSizeIncrement, 20, \
2289 "Adaptive size percentage change in young generation") \
2290 range(0, 100) \
2291 \
2292 product(uintx, YoungGenerationSizeSupplement, 80, \
2293 "Supplement to YoungedGenerationSizeIncrement used at startup") \
2294 range(0, 100) \
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,AfterMemoryInit) \
2317 \
2318 product(uintx, GCPauseIntervalMillis, 0, \
2319 "Time slice for MMU specification") \
2320 constraint(GCPauseIntervalMillisConstraintFunc,AfterMemoryInit) \
2321 \
2322 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
2323 "Adaptive size policy maximum GC minor pause time goal " \
2324 "in millisecond") \
2325 range(0, max_uintx) \
2326 \
2327 product(uintx, GCTimeRatio, 99, \
2328 "Adaptive size policy application time to GC time ratio") \
2329 range(0, max_juint) \
2330 \
2331 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
2332 "Adaptive size scale down factor for shrinking") \
2333 range(1, max_uintx) \
2334 \
2335 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
2336 "Adaptive size decays the major cost for long major intervals") \
2337 \
2338 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
2339 "Time scale over which major costs decay") \
2340 range(0, max_uintx) \
2341 \
2342 product(uintx, MinSurvivorRatio, 3, \
2343 "Minimum ratio of young generation/survivor space size") \
2344 range(3, max_uintx) \
2345 \
2346 product(uintx, InitialSurvivorRatio, 8, \
2347 "Initial ratio of young generation/survivor space size") \
2348 range(0, max_uintx) \
2349 \
2350 product(size_t, BaseFootPrintEstimate, 256*M, \
2351 "Estimate of footprint other than Java Heap") \
2352 range(0, max_uintx) \
2353 \
2354 product(bool, UseGCOverheadLimit, true, \
2355 "Use policy to limit of proportion of time spent in GC " \
2356 "before an OutOfMemory error is thrown") \
2357 \
2358 product(uintx, GCTimeLimit, 98, \
2359 "Limit of the proportion of time spent in GC before " \
2360 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2361 range(0, 100) \
2362 \
2363 product(uintx, GCHeapFreeLimit, 2, \
2364 "Minimum percentage of free space after a full GC before an " \
2365 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2366 range(0, 100) \
2367 \
2368 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2369 "Number of consecutive collections before gc time limit fires") \
2370 range(1, max_uintx) \
2371 \
2372 product(bool, PrintAdaptiveSizePolicy, false, \
2373 "Print information about AdaptiveSizePolicy") \
2374 \
2375 product(intx, PrefetchCopyIntervalInBytes, -1, \
2376 "How far ahead to prefetch destination area (<= 0 means off)") \
2377 range(-1, max_jint) \
2378 \
2379 product(intx, PrefetchScanIntervalInBytes, -1, \
2380 "How far ahead to prefetch scan area (<= 0 means off)") \
2381 range(-1, max_jint) \
2382 \
2383 product(intx, PrefetchFieldsAhead, -1, \
2384 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2385 range(-1, max_jint) \
2386 \
2387 diagnostic(bool, VerifySilently, false, \
2388 "Do not print the verification progress") \
2389 \
2390 diagnostic(bool, VerifyDuringStartup, false, \
2391 "Verify memory system before executing any Java code " \
2392 "during VM initialization") \
2393 \
2394 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2395 "Verify system before exiting") \
2396 \
2397 diagnostic(bool, VerifyBeforeGC, false, \
2398 "Verify memory system before GC") \
2399 \
2400 diagnostic(bool, VerifyAfterGC, false, \
2401 "Verify memory system after GC") \
2402 \
2403 diagnostic(bool, VerifyDuringGC, false, \
2404 "Verify memory system during GC (between phases)") \
2405 \
2413 product(bool, UseCondCardMark, false, \
2414 "Check for already marked card before updating card table") \
2415 \
2416 diagnostic(bool, VerifyRememberedSets, false, \
2417 "Verify GC remembered sets") \
2418 \
2419 diagnostic(bool, VerifyObjectStartArray, true, \
2420 "Verify GC object start array if verify before/after") \
2421 \
2422 product(bool, DisableExplicitGC, false, \
2423 "Ignore calls to System.gc()") \
2424 \
2425 notproduct(bool, CheckMemoryInitialization, false, \
2426 "Check memory initialization") \
2427 \
2428 diagnostic(bool, BindCMSThreadToCPU, false, \
2429 "Bind CMS Thread to CPU if possible") \
2430 \
2431 diagnostic(uintx, CPUForCMSThread, 0, \
2432 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2433 range(0, max_juint) \
2434 \
2435 product(bool, BindGCTaskThreadsToCPUs, false, \
2436 "Bind GCTaskThreads to CPUs if possible") \
2437 \
2438 product(bool, UseGCTaskAffinity, false, \
2439 "Use worker affinity when asking for GCTasks") \
2440 \
2441 product(uintx, ProcessDistributionStride, 4, \
2442 "Stride through processors when distributing processes") \
2443 range(0, max_juint) \
2444 \
2445 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2446 "Number of times the coordinator GC thread will sleep while " \
2447 "yielding before giving up and resuming GC") \
2448 range(0, max_juint) \
2449 \
2450 product(uintx, CMSYieldSleepCount, 0, \
2451 "Number of times a GC thread (minus the coordinator) " \
2452 "will sleep while yielding before giving up and resuming GC") \
2453 range(0, max_juint) \
2454 \
2455 /* gc tracing */ \
2456 manageable(bool, PrintGC, false, \
2457 "Print message at garbage collection") \
2458 \
2459 manageable(bool, PrintGCDetails, false, \
2460 "Print more details at garbage collection") \
2461 \
2462 manageable(bool, PrintGCDateStamps, false, \
2463 "Print date stamps at garbage collection") \
2464 \
2465 manageable(bool, PrintGCTimeStamps, false, \
2466 "Print timestamps at garbage collection") \
2467 \
2468 manageable(bool, PrintGCID, true, \
2469 "Print an identifier for each garbage collection") \
2470 \
2471 product(bool, PrintGCTaskTimeStamps, false, \
2472 "Print timestamps for individual gc worker thread tasks") \
2473 \
2582 "Suppress workaround for libthread GP fault") \
2583 \
2584 product(bool, PrintJNIGCStalls, false, \
2585 "Print diagnostic message when GC is stalled " \
2586 "by JNI critical section") \
2587 \
2588 experimental(double, ObjectCountCutOffPercent, 0.5, \
2589 "The percentage of the used heap that the instances of a class " \
2590 "must occupy for the class to generate a trace event") \
2591 range(0.0, 100.0) \
2592 \
2593 /* GC log rotation setting */ \
2594 \
2595 product(bool, UseGCLogFileRotation, false, \
2596 "Rotate gclog files (for long running applications). It requires "\
2597 "-Xloggc:<filename>") \
2598 \
2599 product(uintx, NumberOfGCLogFiles, 0, \
2600 "Number of gclog files in rotation " \
2601 "(default: 0, no rotation)") \
2602 range(0, max_uintx) \
2603 \
2604 product(size_t, GCLogFileSize, 8*K, \
2605 "GC log file size, requires UseGCLogFileRotation. " \
2606 "Set to 0 to only trigger rotation via jcmd") \
2607 range(0, max_uintx) \
2608 \
2609 /* JVMTI heap profiling */ \
2610 \
2611 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2612 "Trace JVMTI object tagging calls") \
2613 \
2614 diagnostic(bool, VerifyBeforeIteration, false, \
2615 "Verify memory system before JVMTI iteration") \
2616 \
2617 /* compiler interface */ \
2618 \
2619 develop(bool, CIPrintCompilerName, false, \
2620 "when CIPrint is active, print the name of the active compiler") \
2621 \
2622 diagnostic(bool, CIPrintCompileQueue, false, \
2623 "display the contents of the compile queue whenever a " \
2624 "compilation is enqueued") \
2625 \
2626 develop(bool, CIPrintRequests, false, \
2627 "display every request for compilation") \
3355 \
3356 develop(intx, InlineThrowMaxSize, 200, \
3357 "Force inlining of throwing methods smaller than this") \
3358 range(0, max_jint) \
3359 \
3360 develop(intx, ProfilerNodeSize, 1024, \
3361 "Size in K to allocate for the Profile Nodes of each thread") \
3362 range(0, 1024) \
3363 \
3364 /* gc parameters */ \
3365 product(size_t, InitialHeapSize, 0, \
3366 "Initial heap size (in bytes); zero means use ergonomics") \
3367 constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
3368 \
3369 product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
3370 "Maximum heap size (in bytes)") \
3371 constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
3372 \
3373 product(size_t, OldSize, ScaleForWordSize(4*M), \
3374 "Initial tenured generation size (in bytes)") \
3375 range(0, max_uintx) \
3376 \
3377 product(size_t, NewSize, ScaleForWordSize(1*M), \
3378 "Initial new generation size (in bytes)") \
3379 constraint(NewSizeConstraintFunc,AfterErgo) \
3380 \
3381 product(size_t, MaxNewSize, max_uintx, \
3382 "Maximum new generation size (in bytes), max_uintx means set " \
3383 "ergonomically") \
3384 range(0, max_uintx) \
3385 \
3386 product(size_t, PretenureSizeThreshold, 0, \
3387 "Maximum size in bytes of objects allocated in DefNew " \
3388 "generation; zero means no maximum") \
3389 range(0, max_uintx) \
3390 \
3391 product(size_t, MinTLABSize, 2*K, \
3392 "Minimum allowed TLAB size (in bytes)") \
3393 range(1, max_uintx) \
3394 constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
3395 \
3396 product(size_t, TLABSize, 0, \
3397 "Starting TLAB size (in bytes); zero means set ergonomically") \
3398 constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
3399 \
3400 product(size_t, YoungPLABSize, 4096, \
3401 "Size of young gen promotion LAB's (in HeapWords)") \
3402 constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
3403 \
3404 product(size_t, OldPLABSize, 1024, \
3405 "Size of old gen promotion LAB's (in HeapWords), or Number " \
3406 "of blocks to attempt to claim when refilling CMS LAB's") \
3407 constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
3408 \
3409 product(uintx, TLABAllocationWeight, 35, \
3410 "Allocation averaging weight") \
3411 range(0, 100) \
3412 \
3413 /* Limit the lower bound of this flag to 1 as it is used */ \
3414 /* in a division expression. */ \
3415 product(uintx, TLABWasteTargetPercent, 1, \
3416 "Percentage of Eden that can be wasted") \
3417 range(1, 100) \
3418 \
3419 product(uintx, TLABRefillWasteFraction, 64, \
3420 "Maximum TLAB waste at a refill (internal fragmentation)") \
3421 range(1, max_juint) \
3422 \
3423 product(uintx, TLABWasteIncrement, 4, \
3424 "Increment allowed waste at slow allocation") \
3425 range(0, max_jint) \
3426 constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit) \
3427 \
3428 product(uintx, SurvivorRatio, 8, \
3429 "Ratio of eden/survivor space size") \
3430 range(1, max_uintx-2) \
3431 constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
3432 \
3433 product(uintx, NewRatio, 2, \
3434 "Ratio of old/new generation sizes") \
3435 range(0, max_uintx-1) \
3436 \
3437 product_pd(size_t, NewSizeThreadIncrease, \
3438 "Additional size added to desired new generation size per " \
3439 "non-daemon thread (in bytes)") \
3440 range(0, max_uintx) \
3441 \
3442 product_pd(size_t, MetaspaceSize, \
3443 "Initial size of Metaspaces (in bytes)") \
3444 constraint(MetaspaceSizeConstraintFunc,AfterErgo) \
3445 \
3446 product(size_t, MaxMetaspaceSize, max_uintx, \
3447 "Maximum size of Metaspaces (in bytes)") \
3448 constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo) \
3449 \
3450 product(size_t, CompressedClassSpaceSize, 1*G, \
3451 "Maximum size of class area in Metaspace when compressed " \
3452 "class pointers are used") \
3453 range(1*M, 3*G) \
3454 \
3455 manageable(uintx, MinHeapFreeRatio, 40, \
3456 "The minimum percentage of heap free after GC to avoid expansion."\
3457 " For most GCs this applies to the old generation. In G1 and" \
3458 " ParallelGC it applies to the whole heap.") \
3459 range(0, 100) \
3460 constraint(MinHeapFreeRatioConstraintFunc,AfterErgo) \
3461 \
3462 manageable(uintx, MaxHeapFreeRatio, 70, \
3463 "The maximum percentage of heap free after GC to avoid shrinking."\
3464 " For most GCs this applies to the old generation. In G1 and" \
3465 " ParallelGC it applies to the whole heap.") \
3466 range(0, 100) \
3467 constraint(MaxHeapFreeRatioConstraintFunc,AfterErgo) \
3468 \
3469 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
3470 "Number of milliseconds per MB of free space in the heap") \
3471 range(0, max_intx) \
3472 constraint(SoftRefLRUPolicyMSPerMBConstraintFunc,AfterMemoryInit) \
3473 \
3474 product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
3475 "The minimum change in heap space due to GC (in bytes)") \
3476 range(0, max_uintx) \
3477 \
3478 product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
3479 "The minimum expansion of Metaspace (in bytes)") \
3480 range(0, max_uintx) \
3481 \
3482 product(uintx, MaxMetaspaceFreeRatio, 70, \
3483 "The maximum percentage of Metaspace free after GC to avoid " \
3484 "shrinking") \
3485 range(0, 100) \
3486 constraint(MaxMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3487 \
3488 product(uintx, MinMetaspaceFreeRatio, 40, \
3489 "The minimum percentage of Metaspace free after GC to avoid " \
3490 "expansion") \
3491 range(0, 99) \
3492 constraint(MinMetaspaceFreeRatioConstraintFunc,AfterErgo) \
3493 \
3494 product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
3495 "The maximum expansion of Metaspace without full GC (in bytes)") \
3496 range(0, max_uintx) \
3497 \
3498 product(uintx, QueuedAllocationWarningCount, 0, \
3499 "Number of times an allocation that queues behind a GC " \
3500 "will retry before printing a warning") \
3501 range(0, max_uintx) \
3502 \
3503 diagnostic(uintx, VerifyGCStartAt, 0, \
3504 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
3505 range(0, max_uintx) \
3506 \
3507 diagnostic(intx, VerifyGCLevel, 0, \
3508 "Generation level at which to start +VerifyBefore/AfterGC") \
3509 range(0, 1) \
3510 \
3511 product(uintx, MaxTenuringThreshold, 15, \
3512 "Maximum value for tenuring threshold") \
3513 range(0, markOopDesc::max_age + 1) \
3514 constraint(MaxTenuringThresholdConstraintFunc,AfterErgo) \
3515 \
3516 product(uintx, InitialTenuringThreshold, 7, \
3517 "Initial value for tenuring threshold") \
3518 range(0, markOopDesc::max_age + 1) \
3519 constraint(InitialTenuringThresholdConstraintFunc,AfterErgo) \
3520 \
3521 product(uintx, TargetSurvivorRatio, 50, \
3522 "Desired percentage of survivor space used after scavenge") \
3523 range(0, 100) \
3524 \
3525 product(uintx, MarkSweepDeadRatio, 5, \
3526 "Percentage (0-100) of the old gen allowed as dead wood. " \
3527 "Serial mark sweep treats this as both the minimum and maximum " \
3528 "value. " \
3529 "CMS uses this value only if it falls back to mark sweep. " \
3530 "Par compact uses a variable scale based on the density of the " \
3531 "generation and treats this as the maximum value when the heap " \
3532 "is either completely full or completely empty. Par compact " \
3533 "also has a smaller default value; see arguments.cpp.") \
3534 range(0, 100) \
3535 \
3536 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3537 "How often should we fully compact the heap (ignoring the dead " \
3538 "space parameters)") \
3539 range(1, max_uintx) \
3540 \
3541 product(intx, PrintCMSStatistics, 0, \
3542 "Statistics for CMS") \
3543 range(0, 2) \
3544 \
3545 product(bool, PrintCMSInitiationStatistics, false, \
3546 "Statistics for initiating a CMS collection") \
3547 \
3548 product(intx, PrintFLSStatistics, 0, \
3549 "Statistics for CMS' FreeListSpace") \
3550 range(0, 2) \
3551 \
3552 product(intx, PrintFLSCensus, 0, \
3553 "Census for CMS' FreeListSpace") \
3554 range(0, 1) \
3555 \
3556 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3557 "Delay between expansion and allocation (in milliseconds)") \
3558 \
3559 develop(uintx, GCWorkerDelayMillis, 0, \
3560 "Delay in scheduling GC workers (in milliseconds)") \
3561 \
3562 product(intx, DeferThrSuspendLoopCount, 4000, \
3563 "(Unstable) Number of times to iterate in safepoint loop " \
3564 "before blocking VM threads ") \
3565 range(-1, max_jint-1) \
3566 \
3567 product(intx, DeferPollingPageLoopCount, -1, \
3568 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3569 "before changing safepoint polling page to RO ") \
3570 range(-1, max_jint-1) \
3571 \
3572 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3573 range(0, max_intx) \
3574 \
3575 product(bool, PSChunkLargeArrays, true, \
3576 "Process large arrays in chunks") \
3577 \
3578 product(uintx, GCDrainStackTargetSize, 64, \
3579 "Number of entries we will try to leave on the stack " \
3580 "during parallel gc") \
3581 range(0, max_juint) \
3582 \
3583 /* stack parameters */ \
3584 product_pd(intx, StackYellowPages, \
3585 "Number of yellow zone (recoverable overflows) pages") \
3586 range(MIN_STACK_YELLOW_PAGES, (DEFAULT_STACK_YELLOW_PAGES+5)) \
3587 \
3588 product_pd(intx, StackRedPages, \
3589 "Number of red zone (unrecoverable overflows) pages") \
3590 range(MIN_STACK_RED_PAGES, (DEFAULT_STACK_RED_PAGES+2)) \
3591 \
3592 /* greater stack shadow pages can't generate instruction to bang stack */ \
3593 product_pd(intx, StackShadowPages, \
3594 "Number of shadow zone (for overflow checking) pages " \
3595 "this should exceed the depth of the VM and native call stack") \
3596 range(MIN_STACK_SHADOW_PAGES, (DEFAULT_STACK_SHADOW_PAGES+30)) \
3597 \
3598 product_pd(intx, ThreadStackSize, \
3599 "Thread Stack Size (in Kbytes)") \
3600 range(0, max_intx-os::vm_page_size()) \
3601 \
|