966 "Print all malloc/free calls") \
967 \
968 develop(bool, PrintMallocStatistics, false, \
969 "Print malloc/free statistics") \
970 \
971 develop(bool, ZapResourceArea, trueInDebug, \
972 "Zap freed resource/arena space with 0xABABABAB") \
973 \
974 notproduct(bool, ZapVMHandleArea, trueInDebug, \
975 "Zap freed VM handle space with 0xBCBCBCBC") \
976 \
977 develop(bool, ZapJNIHandleArea, trueInDebug, \
978 "Zap freed JNI handle space with 0xFEFEFEFE") \
979 \
980 notproduct(bool, ZapStackSegments, trueInDebug, \
981 "Zap allocated/freed stack segments with 0xFADFADED") \
982 \
983 develop(bool, ZapUnusedHeapArea, trueInDebug, \
984 "Zap unused heap space with 0xBAADBABE") \
985 \
986 develop(bool, TraceZapUnusedHeapArea, false, \
987 "Trace zapping of unused heap space") \
988 \
989 develop(bool, CheckZapUnusedHeapArea, false, \
990 "Check zapping of unused heap space") \
991 \
992 develop(bool, ZapFillerObjects, trueInDebug, \
993 "Zap filler objects with 0xDEAFBABE") \
994 \
995 develop(bool, PrintVMMessages, true, \
996 "Print VM messages on console") \
997 \
998 product(bool, PrintGCApplicationConcurrentTime, false, \
999 "Print the time the application has been running") \
1000 \
1001 product(bool, PrintGCApplicationStoppedTime, false, \
1002 "Print the time the application has been stopped") \
1003 \
1004 diagnostic(bool, VerboseVerification, false, \
1005 "Display detailed verification details") \
1006 \
1007 notproduct(uintx, ErrorHandlerTest, 0, \
1008 "If > 0, provokes an error after VM initialization; the value " \
1009 "determines which error to provoke. See test_error_handler() " \
1010 "in debug.cpp.") \
1011 \
1012 notproduct(uintx, TestCrashInErrorHandler, 0, \
1013 "If > 0, provokes an error inside VM error handler (a secondary " \
1014 "crash). see test_error_handler() in debug.cpp.") \
1015 \
1016 notproduct(bool, TestSafeFetchInErrorHandler, false, \
1017 "If true, tests SafeFetch inside error handler.") \
1018 \
1019 develop(bool, Verbose, false, \
1020 "Print additional debugging information from other modes") \
1021 \
1022 develop(bool, PrintMiscellaneous, false, \
1023 "Print uncategorized debugging information (requires +Verbose)") \
1569 "Number of parallel threads parallel gc will use") \
1570 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1571 \
1572 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1573 "Use semaphore synchronization for the GC Threads, " \
1574 "instead of synchronization based on mutexes") \
1575 \
1576 product(bool, UseDynamicNumberOfGCThreads, false, \
1577 "Dynamically choose the number of parallel threads " \
1578 "parallel gc will use") \
1579 \
1580 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1581 "Force dynamic selection of the number of " \
1582 "parallel threads parallel gc will use to aid debugging") \
1583 \
1584 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1585 "Size of heap (bytes) per GC thread used in calculating the " \
1586 "number of GC threads") \
1587 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1588 \
1589 product(bool, TraceDynamicGCThreads, false, \
1590 "Trace the dynamic GC thread usage") \
1591 \
1592 product(uint, ConcGCThreads, 0, \
1593 "Number of threads concurrent gc will use") \
1594 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1595 \
1596 product(uintx, GCTaskTimeStampEntries, 200, \
1597 "Number of time stamp entries per gc worker thread") \
1598 range(1, max_uintx) \
1599 \
1600 product(bool, AlwaysTenure, false, \
1601 "Always tenure objects in eden (ParallelGC only)") \
1602 \
1603 product(bool, NeverTenure, false, \
1604 "Never tenure objects in eden, may tenure on overflow " \
1605 "(ParallelGC only)") \
1606 \
1607 product(bool, ScavengeBeforeFullGC, true, \
1608 "Scavenge youngest generation before each full GC.") \
1609 \
1610 product(bool, UseConcMarkSweepGC, false, \
1611 "Use Concurrent Mark-Sweep GC in the old generation") \
1621 \
1622 product(bool, GCLockerInvokesConcurrent, false, \
1623 "The exit of a JNI critical section necessitating a scavenge, " \
1624 "also kicks off a background concurrent collection") \
1625 \
1626 product(uintx, GCLockerEdenExpansionPercent, 5, \
1627 "How much the GC can expand the eden by while the GC locker " \
1628 "is active (as a percentage)") \
1629 range(0, 100) \
1630 \
1631 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1632 "Number of times to retry allocations when " \
1633 "blocked by the GC locker") \
1634 \
1635 product(bool, UseCMSBestFit, true, \
1636 "Use CMS best fit allocation strategy") \
1637 \
1638 product(bool, UseParNewGC, false, \
1639 "Use parallel threads in the new generation") \
1640 \
1641 product(bool, PrintTaskqueue, false, \
1642 "Print taskqueue statistics for parallel collectors") \
1643 \
1644 product(bool, PrintTerminationStats, false, \
1645 "Print termination statistics for parallel collectors") \
1646 \
1647 product(uintx, ParallelGCBufferWastePct, 10, \
1648 "Wasted fraction of parallel allocation buffer") \
1649 range(0, 100) \
1650 \
1651 product(uintx, TargetPLABWastePct, 10, \
1652 "Target wasted space in last buffer as percent of overall " \
1653 "allocation") \
1654 range(1, 100) \
1655 \
1656 product(uintx, PLABWeight, 75, \
1657 "Percentage (0-100) used to weight the current sample when " \
1658 "computing exponentially decaying average for ResizePLAB") \
1659 range(0, 100) \
1660 \
1661 product(bool, ResizePLAB, true, \
1662 "Dynamically resize (survivor space) promotion LAB's") \
1663 \
1664 product(bool, PrintPLAB, false, \
1665 "Print (survivor space) promotion LAB's sizing decisions") \
1666 \
1667 product(intx, ParGCArrayScanChunk, 50, \
1668 "Scan a subset of object array and push remainder, if array is " \
1669 "bigger than this") \
1670 range(1, max_intx) \
1671 \
1672 product(bool, ParGCUseLocalOverflow, false, \
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, \
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 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1694 \
1695 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1696 "The number of cards in each chunk of the parallel chunks used " \
1697 "during card table scanning") \
1698 range(1, max_intx) \
1699 \
1700 product(uintx, OldPLABWeight, 50, \
1701 "Percentage (0-100) used to weight the current sample when " \
1702 "computing exponentially decaying average for resizing " \
1703 "OldPLABSize") \
1704 range(0, 100) \
1705 \
1706 product(bool, ResizeOldPLAB, true, \
1707 "Dynamically resize (old gen) promotion LAB's") \
1708 \
1709 product(bool, PrintOldPLAB, false, \
1710 "Print (old gen) promotion LAB's sizing decisions") \
1711 \
1712 product(size_t, CMSOldPLABMax, 1024, \
1713 "Maximum size of CMS gen promotion LAB caches per worker " \
1714 "per block size") \
1715 range(1, max_uintx) \
1716 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1717 \
1718 product(size_t, CMSOldPLABMin, 16, \
1719 "Minimum size of CMS gen promotion LAB caches per worker " \
1720 "per block size") \
1721 range(1, max_uintx) \
1722 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1723 \
1724 product(uintx, CMSOldPLABNumRefills, 4, \
1725 "Nominal number of refills of CMS gen promotion LAB cache " \
1726 "per worker per block size") \
1727 range(1, max_uintx) \
1728 \
1729 product(bool, CMSOldPLABResizeQuicker, false, \
1730 "React on-the-fly during a scavenge to a sudden " \
1731 "change in block demand rate") \
1883 "Whether abort-on-overflow semantics is implemented") \
1884 \
1885 product(bool, CMSParallelInitialMarkEnabled, true, \
1886 "Use the parallel initial mark.") \
1887 \
1888 product(bool, CMSParallelRemarkEnabled, true, \
1889 "Whether parallel remark enabled (only if ParNewGC)") \
1890 \
1891 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1892 "Whether parallel remark of survivor space " \
1893 "enabled (effective only if CMSParallelRemarkEnabled)") \
1894 \
1895 product(bool, CMSPLABRecordAlways, true, \
1896 "Always record survivor space PLAB boundaries (effective only " \
1897 "if CMSParallelSurvivorRemarkEnabled)") \
1898 \
1899 product(bool, CMSEdenChunksRecordAlways, true, \
1900 "Always record eden chunks used for the parallel initial mark " \
1901 "or remark of eden") \
1902 \
1903 product(bool, CMSPrintEdenSurvivorChunks, false, \
1904 "Print the eden and the survivor chunks used for the parallel " \
1905 "initial mark or remark of the eden/survivor spaces") \
1906 \
1907 product(bool, CMSConcurrentMTEnabled, true, \
1908 "Whether multi-threaded concurrent work enabled " \
1909 "(effective only if ParNewGC)") \
1910 \
1911 product(bool, CMSPrecleaningEnabled, true, \
1912 "Whether concurrent precleaning enabled") \
1913 \
1914 product(uintx, CMSPrecleanIter, 3, \
1915 "Maximum number of precleaning iteration passes") \
1916 range(0, 9) \
1917 \
1918 product(uintx, CMSPrecleanDenominator, 3, \
1919 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1920 "ratio") \
1921 range(1, max_uintx) \
1922 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1923 \
1924 product(uintx, CMSPrecleanNumerator, 2, \
1925 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1926 "ratio") \
1954 "If Eden size is below this, do not try to schedule remark") \
1955 \
1956 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1957 "The Eden occupancy percentage (0-100) at which " \
1958 "to try and schedule remark pause") \
1959 range(0, 100) \
1960 \
1961 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1962 "Start sampling eden top at least before young gen " \
1963 "occupancy reaches 1/<ratio> of the size at which " \
1964 "we plan to schedule remark") \
1965 range(1, max_uintx) \
1966 \
1967 product(uintx, CMSSamplingGrain, 16*K, \
1968 "The minimum distance between eden samples for CMS (see above)") \
1969 range(1, max_uintx) \
1970 \
1971 product(bool, CMSScavengeBeforeRemark, false, \
1972 "Attempt scavenge before the CMS remark step") \
1973 \
1974 develop(bool, CMSTraceSweeper, false, \
1975 "Trace some actions of the CMS sweeper") \
1976 \
1977 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1978 "Don't drain below this size per parallel worker/thief") \
1979 range(1, max_juint) \
1980 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1981 \
1982 manageable(intx, CMSWaitDuration, 2000, \
1983 "Time in milliseconds that CMS thread waits for young GC") \
1984 \
1985 develop(uintx, CMSCheckInterval, 1000, \
1986 "Interval in milliseconds that CMS thread checks if it " \
1987 "should start a collection cycle") \
1988 \
1989 product(bool, CMSYield, true, \
1990 "Yield between steps of CMS") \
1991 \
1992 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1993 "Bitmap operations should process at most this many bits " \
1994 "between yields") \
1995 range(1, max_uintx) \
1996 \
1997 product(bool, CMSDumpAtPromotionFailure, false, \
1998 "Dump useful information about the state of the CMS old " \
1999 "generation upon a promotion failure") \
2000 \
2001 product(bool, CMSPrintChunksInDump, false, \
2002 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
2003 "more detailed information about the free chunks") \
2004 \
2005 product(bool, CMSPrintObjectsInDump, false, \
2006 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
2007 "more detailed information about the allocated objects") \
2008 \
2009 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
2010 "Verify that all references across the FLS boundary " \
2011 "are to valid objects") \
2012 \
2013 diagnostic(bool, FLSVerifyLists, false, \
2014 "Do lots of (expensive) FreeListSpace verification") \
2015 \
2016 diagnostic(bool, FLSVerifyIndexTable, false, \
2017 "Do lots of (expensive) FLS index table verification") \
2018 \
2019 develop(bool, FLSVerifyDictionary, false, \
2020 "Do lots of (expensive) FLS dictionary verification") \
2021 \
2022 develop(bool, VerifyBlockOffsetArray, false, \
2023 "Do (expensive) block offset array verification") \
2024 \
2025 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
2026 "Maintain _unallocated_block in BlockOffsetArray " \
2027 "(currently applicable only to CMS collector)") \
2028 \
2029 develop(bool, TraceCMSState, false, \
2030 "Trace the state of the CMS collection") \
2031 \
2032 product(intx, RefDiscoveryPolicy, 0, \
2033 "Select type of reference discovery policy: " \
2034 "reference-based(0) or referent-based(1)") \
2035 range(ReferenceProcessor::DiscoveryPolicyMin, \
2036 ReferenceProcessor::DiscoveryPolicyMax) \
2037 \
2038 product(bool, ParallelRefProcEnabled, false, \
2039 "Enable parallel reference processing whenever possible") \
2040 \
2041 product(bool, ParallelRefProcBalancingEnabled, true, \
2042 "Enable balancing of reference processing queues") \
2043 \
2044 product(uintx, CMSTriggerRatio, 80, \
2045 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2046 "allocated before a CMS collection cycle commences") \
2047 range(0, 100) \
2048 \
2049 product(uintx, CMSBootstrapOccupancy, 50, \
2050 "Percentage CMS generation occupancy at which to " \
2051 "initiate CMS collection for bootstrapping collection stats") \
2075 product(uintx, CMSIsTooFullPercentage, 98, \
2076 "An absolute ceiling above which CMS will always consider the " \
2077 "unloading of classes when class unloading is enabled") \
2078 range(0, 100) \
2079 \
2080 notproduct(bool, CMSVerifyReturnedBytes, false, \
2081 "Check that all the garbage collected was returned to the " \
2082 "free lists") \
2083 \
2084 notproduct(bool, ScavengeALot, false, \
2085 "Force scavenge at every Nth exit from the runtime system " \
2086 "(N=ScavengeALotInterval)") \
2087 \
2088 develop(bool, FullGCALot, false, \
2089 "Force full gc at every Nth exit from the runtime system " \
2090 "(N=FullGCALotInterval)") \
2091 \
2092 notproduct(bool, GCALotAtAllSafepoints, false, \
2093 "Enforce ScavengeALot/GCALot at all potential safepoints") \
2094 \
2095 product(bool, PrintPromotionFailure, false, \
2096 "Print additional diagnostic information following " \
2097 "promotion failure") \
2098 \
2099 notproduct(bool, PromotionFailureALot, false, \
2100 "Use promotion failure handling on every youngest generation " \
2101 "collection") \
2102 \
2103 develop(uintx, PromotionFailureALotCount, 1000, \
2104 "Number of promotion failures occurring at PLAB " \
2105 "refill attempts (ParNew) or promotion attempts " \
2106 "(other young collectors)") \
2107 \
2108 develop(uintx, PromotionFailureALotInterval, 5, \
2109 "Total collections between promotion failures a lot") \
2110 \
2111 experimental(uintx, WorkStealingSleepMillis, 1, \
2112 "Sleep time when sleep is used for yields") \
2113 \
2114 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
2115 "Number of yields before a sleep is done during work stealing") \
2116 \
2117 experimental(uintx, WorkStealingHardSpins, 4096, \
2118 "Number of iterations in a spin loop between checks on " \
2119 "time out of hard spin") \
2120 \
2121 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
2122 "Ratio of hard spins to calls to yield") \
2123 \
2124 develop(uintx, ObjArrayMarkingStride, 512, \
2125 "Number of object array elements to push onto the marking stack " \
2126 "before pushing a continuation entry") \
2127 \
2128 develop(bool, MetadataAllocationFailALot, false, \
2129 "Fail metadata allocations at intervals controlled by " \
2130 "MetadataAllocationFailALotInterval") \
2131 \
2132 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
2133 "Metadata allocation failure a lot interval") \
2134 \
2135 develop(bool, TraceMetadataChunkAllocation, false, \
2136 "Trace chunk metadata allocations") \
2137 \
2138 product(bool, TraceMetadataHumongousAllocation, false, \
2139 "Trace humongous metadata allocations") \
2140 \
2141 develop(bool, TraceMetavirtualspaceAllocation, false, \
2142 "Trace virtual space metadata allocations") \
2143 \
2144 notproduct(bool, ExecuteInternalVMTests, false, \
2145 "Enable execution of internal VM tests") \
2146 \
2147 notproduct(bool, VerboseInternalVMTests, false, \
2148 "Turn on logging for internal VM tests.") \
2149 \
2150 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
2151 \
2152 product_pd(bool, ResizeTLAB, \
2153 "Dynamically resize TLAB size for threads") \
2154 \
2155 product(bool, ZeroTLAB, false, \
2156 "Zero out the newly created TLAB") \
2157 \
2158 product(bool, FastTLABRefill, true, \
2159 "Use fast TLAB refill code") \
2160 \
2161 product(bool, PrintTLAB, false, \
2162 "Print various TLAB related information") \
2163 \
2164 product(bool, TLABStats, true, \
2165 "Provide more detailed and expensive TLAB statistics " \
2166 "(with PrintTLAB)") \
2167 \
2168 product_pd(bool, NeverActAsServerClassMachine, \
2169 "Never act like a server-class machine") \
2170 \
2171 product(bool, AlwaysActAsServerClassMachine, false, \
2172 "Always act like a server-class machine") \
2173 \
2174 product_pd(uint64_t, MaxRAM, \
2175 "Real memory size (in bytes) used to set maximum heap size") \
2176 range(0, 0XFFFFFFFFFFFFFFFF) \
2177 \
2178 product(size_t, ErgoHeapSizeLimit, 0, \
2179 "Maximum ergonomically set heap size (in bytes); zero means use " \
2180 "MaxRAM / MaxRAMFraction") \
2181 \
2182 product(uintx, MaxRAMFraction, 4, \
2183 "Maximum fraction (1/n) of real memory used for maximum heap " \
2184 "size") \
2185 range(1, max_uintx) \
2186 \
2204 "Automatic GC selection pause threshold in milliseconds") \
2205 \
2206 product(bool, UseAdaptiveSizePolicy, true, \
2207 "Use adaptive generation sizing policies") \
2208 \
2209 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2210 "Use adaptive survivor sizing policies") \
2211 \
2212 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2213 "Use adaptive young-old sizing policies at minor collections") \
2214 \
2215 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2216 "Use adaptive young-old sizing policies at major collections") \
2217 \
2218 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2219 "Include statistics from System.gc() for adaptive size policy") \
2220 \
2221 product(bool, UseAdaptiveGCBoundary, false, \
2222 "Allow young-old boundary to move") \
2223 \
2224 develop(bool, TraceAdaptiveGCBoundary, false, \
2225 "Trace young-old boundary moves") \
2226 \
2227 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2228 "Resize the virtual spaces of the young or old generations") \
2229 range(-1, 1) \
2230 \
2231 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2232 "Policy for changing generation size for throughput goals") \
2233 range(0, 1) \
2234 \
2235 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2236 "Number of steps where heuristics is used before data is used") \
2237 \
2238 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2239 "Number of collections before the adaptive sizing is started") \
2240 \
2241 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2242 "Collection interval for printing information; zero means never") \
2243 \
2244 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2245 "Use adaptive minimum footprint as a goal") \
2246 \
2331 "Estimate of footprint other than Java Heap") \
2332 \
2333 product(bool, UseGCOverheadLimit, true, \
2334 "Use policy to limit of proportion of time spent in GC " \
2335 "before an OutOfMemory error is thrown") \
2336 \
2337 product(uintx, GCTimeLimit, 98, \
2338 "Limit of the proportion of time spent in GC before " \
2339 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2340 range(0, 100) \
2341 \
2342 product(uintx, GCHeapFreeLimit, 2, \
2343 "Minimum percentage of free space after a full GC before an " \
2344 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2345 range(0, 100) \
2346 \
2347 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2348 "Number of consecutive collections before gc time limit fires") \
2349 range(1, max_uintx) \
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 \
2370 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2371 "Verify system before exiting") \
2372 \
2373 diagnostic(bool, VerifyBeforeGC, false, \
2374 "Verify memory system before GC") \
2375 \
2376 diagnostic(bool, VerifyAfterGC, false, \
2377 "Verify memory system after GC") \
2378 \
2379 diagnostic(bool, VerifyDuringGC, false, \
2380 "Verify memory system during GC (between phases)") \
2381 \
2382 diagnostic(bool, GCParallelVerificationEnabled, true, \
2383 "Enable parallel memory system verification") \
2384 \
2385 diagnostic(bool, DeferInitialCardMark, false, \
2414 "Use worker affinity when asking for GCTasks") \
2415 \
2416 product(uintx, ProcessDistributionStride, 4, \
2417 "Stride through processors when distributing processes") \
2418 \
2419 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2420 "Number of times the coordinator GC thread will sleep while " \
2421 "yielding before giving up and resuming GC") \
2422 \
2423 product(uintx, CMSYieldSleepCount, 0, \
2424 "Number of times a GC thread (minus the coordinator) " \
2425 "will sleep while yielding before giving up and resuming GC") \
2426 \
2427 /* gc tracing */ \
2428 manageable(bool, PrintGC, false, \
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 range(0, max_intx) \
2450 \
2451 product(bool, PrintReferenceGC, false, \
2452 "Print times spent handling reference objects during GC " \
2453 "(enabled only when PrintGCDetails)") \
2454 \
2455 develop(bool, TraceReferenceGC, false, \
2456 "Trace handling of soft/weak/final/phantom references") \
2457 \
2458 develop(bool, TraceFinalizerRegistration, false, \
2459 "Trace registration of final references") \
2460 \
2461 notproduct(bool, TraceScavenge, false, \
2462 "Trace scavenge") \
2463 \
2464 product(bool, IgnoreEmptyClassPaths, false, \
2465 "Ignore empty path elements in -classpath") \
2466 \
2467 product(bool, TraceClassPaths, false, \
2468 "Trace processing of class paths") \
2469 \
2470 product_rw(bool, TraceClassLoading, false, \
2471 "Trace all classes loaded") \
2472 \
2473 product(bool, TraceClassLoadingPreorder, false, \
2474 "Trace all classes loaded in order referenced (not loaded)") \
2475 \
2476 product_rw(bool, TraceClassUnloading, false, \
2477 "Trace unloading of classes") \
2478 \
2479 product_rw(bool, TraceLoaderConstraints, false, \
2480 "Trace loader constraints") \
2481 \
2482 develop(bool, TraceClassLoaderData, false, \
2483 "Trace class loader loader_data lifetime") \
2484 \
2485 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2486 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2487 "Initial size of the boot class loader data metaspace") \
2488 range(30*K, max_uintx/BytesPerWord) \
2489 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2490 \
2491 product(bool, TraceYoungGenTime, false, \
2492 "Trace accumulated time for young collection") \
2493 \
2494 product(bool, TraceOldGenTime, false, \
2495 "Trace accumulated time for old collection") \
2496 \
2497 product(bool, PrintTenuringDistribution, false, \
2498 "Print tenuring age information") \
2499 \
2500 product_rw(bool, PrintHeapAtGC, false, \
2501 "Print heap layout before and after each GC") \
2502 \
2503 product_rw(bool, PrintHeapAtGCExtended, false, \
2504 "Print extended information about the layout of the heap " \
2505 "when -XX:+PrintHeapAtGC is set") \
2506 \
2507 product(bool, PrintHeapAtSIGBREAK, true, \
2508 "Print heap layout in response to SIGBREAK") \
2509 \
2510 manageable(bool, PrintClassHistogramBeforeFullGC, false, \
2511 "Print a class histogram before any major stop-world GC") \
2512 \
2513 manageable(bool, PrintClassHistogramAfterFullGC, false, \
2514 "Print a class histogram after any major stop-world GC") \
2515 \
2516 manageable(bool, PrintClassHistogram, false, \
2517 "Print a histogram of class instances") \
2518 \
2519 develop(bool, TraceWorkGang, false, \
2520 "Trace activities of work gangs") \
2521 \
2522 product(bool, TraceParallelOldGCTasks, false, \
2523 "Trace multithreaded GC activity") \
2524 \
2525 develop(bool, TraceBlockOffsetTable, false, \
2526 "Print BlockOffsetTable maps") \
2527 \
2528 develop(bool, TraceCardTableModRefBS, false, \
2529 "Print CardTableModRefBS maps") \
2530 \
2531 develop(bool, TraceGCTaskManager, false, \
2532 "Trace actions of the GC task manager") \
2533 \
2534 develop(bool, TraceGCTaskQueue, false, \
2535 "Trace actions of the GC task queues") \
2536 \
2537 diagnostic(bool, TraceGCTaskThread, false, \
2538 "Trace actions of the GC task threads") \
2539 \
2540 product(bool, PrintParallelOldGCPhaseTimes, false, \
2541 "Print the time taken by each phase in ParallelOldGC " \
2542 "(PrintGCDetails must also be enabled)") \
2543 \
2544 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2545 "Trace marking phase in ParallelOldGC") \
2546 \
2547 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2548 "Trace summary phase in ParallelOldGC") \
2549 \
2550 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2551 "Trace compaction phase in ParallelOldGC") \
2552 \
2553 develop(bool, TraceParallelOldGCDensePrefix, false, \
2554 "Trace dense prefix computation for ParallelOldGC") \
2555 \
2556 develop(bool, IgnoreLibthreadGPFault, false, \
2557 "Suppress workaround for libthread GP fault") \
2558 \
2559 product(bool, PrintJNIGCStalls, false, \
2560 "Print diagnostic message when GC is stalled " \
2561 "by JNI critical section") \
2562 \
2563 experimental(double, ObjectCountCutOffPercent, 0.5, \
2564 "The percentage of the used heap that the instances of a class " \
2565 "must occupy for the class to generate a trace event") \
2566 range(0.0, 100.0) \
2567 \
2568 /* GC log rotation setting */ \
2569 \
2570 product(bool, UseGCLogFileRotation, false, \
2571 "Rotate gclog files (for long running applications). It requires "\
2572 "-Xloggc:<filename>") \
3473 \
3474 product(uintx, TargetSurvivorRatio, 50, \
3475 "Desired percentage of survivor space used after scavenge") \
3476 range(0, 100) \
3477 \
3478 product(uintx, MarkSweepDeadRatio, 5, \
3479 "Percentage (0-100) of the old gen allowed as dead wood. " \
3480 "Serial mark sweep treats this as both the minimum and maximum " \
3481 "value. " \
3482 "CMS uses this value only if it falls back to mark sweep. " \
3483 "Par compact uses a variable scale based on the density of the " \
3484 "generation and treats this as the maximum value when the heap " \
3485 "is either completely full or completely empty. Par compact " \
3486 "also has a smaller default value; see arguments.cpp.") \
3487 range(0, 100) \
3488 \
3489 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3490 "How often should we fully compact the heap (ignoring the dead " \
3491 "space parameters)") \
3492 range(1, max_uintx) \
3493 \
3494 product(intx, PrintCMSStatistics, 0, \
3495 "Statistics for CMS") \
3496 \
3497 product(bool, PrintCMSInitiationStatistics, false, \
3498 "Statistics for initiating a CMS collection") \
3499 \
3500 product(intx, PrintFLSStatistics, 0, \
3501 "Statistics for CMS' FreeListSpace") \
3502 \
3503 product(intx, PrintFLSCensus, 0, \
3504 "Census for CMS' FreeListSpace") \
3505 \
3506 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3507 "Delay between expansion and allocation (in milliseconds)") \
3508 \
3509 develop(uintx, GCWorkerDelayMillis, 0, \
3510 "Delay in scheduling GC workers (in milliseconds)") \
3511 \
3512 product(intx, DeferThrSuspendLoopCount, 4000, \
3513 "(Unstable) Number of times to iterate in safepoint loop " \
3514 "before blocking VM threads ") \
3515 range(-1, max_jint-1) \
3516 \
3517 product(intx, DeferPollingPageLoopCount, -1, \
3518 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3519 "before changing safepoint polling page to RO ") \
3520 range(-1, max_jint-1) \
3521 \
3522 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3523 range(0, max_intx) \
3524 \
|
966 "Print all malloc/free calls") \
967 \
968 develop(bool, PrintMallocStatistics, false, \
969 "Print malloc/free statistics") \
970 \
971 develop(bool, ZapResourceArea, trueInDebug, \
972 "Zap freed resource/arena space with 0xABABABAB") \
973 \
974 notproduct(bool, ZapVMHandleArea, trueInDebug, \
975 "Zap freed VM handle space with 0xBCBCBCBC") \
976 \
977 develop(bool, ZapJNIHandleArea, trueInDebug, \
978 "Zap freed JNI handle space with 0xFEFEFEFE") \
979 \
980 notproduct(bool, ZapStackSegments, trueInDebug, \
981 "Zap allocated/freed stack segments with 0xFADFADED") \
982 \
983 develop(bool, ZapUnusedHeapArea, trueInDebug, \
984 "Zap unused heap space with 0xBAADBABE") \
985 \
986 develop(bool, CheckZapUnusedHeapArea, false, \
987 "Check zapping of unused heap space") \
988 \
989 develop(bool, ZapFillerObjects, trueInDebug, \
990 "Zap filler objects with 0xDEAFBABE") \
991 \
992 develop(bool, PrintVMMessages, true, \
993 "Print VM messages on console") \
994 \
995 diagnostic(bool, VerboseVerification, false, \
996 "Display detailed verification details") \
997 \
998 notproduct(uintx, ErrorHandlerTest, 0, \
999 "If > 0, provokes an error after VM initialization; the value " \
1000 "determines which error to provoke. See test_error_handler() " \
1001 "in debug.cpp.") \
1002 \
1003 notproduct(uintx, TestCrashInErrorHandler, 0, \
1004 "If > 0, provokes an error inside VM error handler (a secondary " \
1005 "crash). see test_error_handler() in debug.cpp.") \
1006 \
1007 notproduct(bool, TestSafeFetchInErrorHandler, false, \
1008 "If true, tests SafeFetch inside error handler.") \
1009 \
1010 develop(bool, Verbose, false, \
1011 "Print additional debugging information from other modes") \
1012 \
1013 develop(bool, PrintMiscellaneous, false, \
1014 "Print uncategorized debugging information (requires +Verbose)") \
1560 "Number of parallel threads parallel gc will use") \
1561 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1562 \
1563 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1564 "Use semaphore synchronization for the GC Threads, " \
1565 "instead of synchronization based on mutexes") \
1566 \
1567 product(bool, UseDynamicNumberOfGCThreads, false, \
1568 "Dynamically choose the number of parallel threads " \
1569 "parallel gc will use") \
1570 \
1571 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1572 "Force dynamic selection of the number of " \
1573 "parallel threads parallel gc will use to aid debugging") \
1574 \
1575 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1576 "Size of heap (bytes) per GC thread used in calculating the " \
1577 "number of GC threads") \
1578 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1579 \
1580 product(uint, ConcGCThreads, 0, \
1581 "Number of threads concurrent gc will use") \
1582 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1583 \
1584 product(uintx, GCTaskTimeStampEntries, 200, \
1585 "Number of time stamp entries per gc worker thread") \
1586 range(1, max_uintx) \
1587 \
1588 product(bool, AlwaysTenure, false, \
1589 "Always tenure objects in eden (ParallelGC only)") \
1590 \
1591 product(bool, NeverTenure, false, \
1592 "Never tenure objects in eden, may tenure on overflow " \
1593 "(ParallelGC only)") \
1594 \
1595 product(bool, ScavengeBeforeFullGC, true, \
1596 "Scavenge youngest generation before each full GC.") \
1597 \
1598 product(bool, UseConcMarkSweepGC, false, \
1599 "Use Concurrent Mark-Sweep GC in the old generation") \
1609 \
1610 product(bool, GCLockerInvokesConcurrent, false, \
1611 "The exit of a JNI critical section necessitating a scavenge, " \
1612 "also kicks off a background concurrent collection") \
1613 \
1614 product(uintx, GCLockerEdenExpansionPercent, 5, \
1615 "How much the GC can expand the eden by while the GC locker " \
1616 "is active (as a percentage)") \
1617 range(0, 100) \
1618 \
1619 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1620 "Number of times to retry allocations when " \
1621 "blocked by the GC locker") \
1622 \
1623 product(bool, UseCMSBestFit, true, \
1624 "Use CMS best fit allocation strategy") \
1625 \
1626 product(bool, UseParNewGC, false, \
1627 "Use parallel threads in the new generation") \
1628 \
1629 product(uintx, ParallelGCBufferWastePct, 10, \
1630 "Wasted fraction of parallel allocation buffer") \
1631 range(0, 100) \
1632 \
1633 product(uintx, TargetPLABWastePct, 10, \
1634 "Target wasted space in last buffer as percent of overall " \
1635 "allocation") \
1636 range(1, 100) \
1637 \
1638 product(uintx, PLABWeight, 75, \
1639 "Percentage (0-100) used to weight the current sample when " \
1640 "computing exponentially decaying average for ResizePLAB") \
1641 range(0, 100) \
1642 \
1643 product(bool, ResizePLAB, true, \
1644 "Dynamically resize (survivor space) promotion LAB's") \
1645 \
1646 product(intx, ParGCArrayScanChunk, 50, \
1647 "Scan a subset of object array and push remainder, if array is " \
1648 "bigger than this") \
1649 range(1, max_intx) \
1650 \
1651 product(bool, ParGCUseLocalOverflow, false, \
1652 "Instead of a global overflow list, use local overflow stacks") \
1653 \
1654 product(bool, ParGCTrimOverflow, true, \
1655 "Eagerly trim the local overflow lists " \
1656 "(when ParGCUseLocalOverflow)") \
1657 \
1658 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1659 "Simulate work queue overflow in ParNew") \
1660 \
1661 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1662 "An `interval' counter that determines how frequently " \
1663 "we simulate overflow; a smaller number increases frequency") \
1664 \
1665 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1668 diagnostic(uintx, ParGCStridesPerThread, 2, \
1669 "The number of strides per worker thread that we divide up the " \
1670 "card table scanning work into") \
1671 range(1, max_uintx) \
1672 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1673 \
1674 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1675 "The number of cards in each chunk of the parallel chunks used " \
1676 "during card table scanning") \
1677 range(1, max_intx) \
1678 \
1679 product(uintx, OldPLABWeight, 50, \
1680 "Percentage (0-100) used to weight the current sample when " \
1681 "computing exponentially decaying average for resizing " \
1682 "OldPLABSize") \
1683 range(0, 100) \
1684 \
1685 product(bool, ResizeOldPLAB, true, \
1686 "Dynamically resize (old gen) promotion LAB's") \
1687 \
1688 product(size_t, CMSOldPLABMax, 1024, \
1689 "Maximum size of CMS gen promotion LAB caches per worker " \
1690 "per block size") \
1691 range(1, max_uintx) \
1692 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1693 \
1694 product(size_t, CMSOldPLABMin, 16, \
1695 "Minimum size of CMS gen promotion LAB caches per worker " \
1696 "per block size") \
1697 range(1, max_uintx) \
1698 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1699 \
1700 product(uintx, CMSOldPLABNumRefills, 4, \
1701 "Nominal number of refills of CMS gen promotion LAB cache " \
1702 "per worker per block size") \
1703 range(1, max_uintx) \
1704 \
1705 product(bool, CMSOldPLABResizeQuicker, false, \
1706 "React on-the-fly during a scavenge to a sudden " \
1707 "change in block demand rate") \
1859 "Whether abort-on-overflow semantics is implemented") \
1860 \
1861 product(bool, CMSParallelInitialMarkEnabled, true, \
1862 "Use the parallel initial mark.") \
1863 \
1864 product(bool, CMSParallelRemarkEnabled, true, \
1865 "Whether parallel remark enabled (only if ParNewGC)") \
1866 \
1867 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1868 "Whether parallel remark of survivor space " \
1869 "enabled (effective only if CMSParallelRemarkEnabled)") \
1870 \
1871 product(bool, CMSPLABRecordAlways, true, \
1872 "Always record survivor space PLAB boundaries (effective only " \
1873 "if CMSParallelSurvivorRemarkEnabled)") \
1874 \
1875 product(bool, CMSEdenChunksRecordAlways, true, \
1876 "Always record eden chunks used for the parallel initial mark " \
1877 "or remark of eden") \
1878 \
1879 product(bool, CMSConcurrentMTEnabled, true, \
1880 "Whether multi-threaded concurrent work enabled " \
1881 "(effective only if ParNewGC)") \
1882 \
1883 product(bool, CMSPrecleaningEnabled, true, \
1884 "Whether concurrent precleaning enabled") \
1885 \
1886 product(uintx, CMSPrecleanIter, 3, \
1887 "Maximum number of precleaning iteration passes") \
1888 range(0, 9) \
1889 \
1890 product(uintx, CMSPrecleanDenominator, 3, \
1891 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1892 "ratio") \
1893 range(1, max_uintx) \
1894 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1895 \
1896 product(uintx, CMSPrecleanNumerator, 2, \
1897 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1898 "ratio") \
1926 "If Eden size is below this, do not try to schedule remark") \
1927 \
1928 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1929 "The Eden occupancy percentage (0-100) at which " \
1930 "to try and schedule remark pause") \
1931 range(0, 100) \
1932 \
1933 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1934 "Start sampling eden top at least before young gen " \
1935 "occupancy reaches 1/<ratio> of the size at which " \
1936 "we plan to schedule remark") \
1937 range(1, max_uintx) \
1938 \
1939 product(uintx, CMSSamplingGrain, 16*K, \
1940 "The minimum distance between eden samples for CMS (see above)") \
1941 range(1, max_uintx) \
1942 \
1943 product(bool, CMSScavengeBeforeRemark, false, \
1944 "Attempt scavenge before the CMS remark step") \
1945 \
1946 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1947 "Don't drain below this size per parallel worker/thief") \
1948 range(1, max_juint) \
1949 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1950 \
1951 manageable(intx, CMSWaitDuration, 2000, \
1952 "Time in milliseconds that CMS thread waits for young GC") \
1953 \
1954 develop(uintx, CMSCheckInterval, 1000, \
1955 "Interval in milliseconds that CMS thread checks if it " \
1956 "should start a collection cycle") \
1957 \
1958 product(bool, CMSYield, true, \
1959 "Yield between steps of CMS") \
1960 \
1961 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1962 "Bitmap operations should process at most this many bits " \
1963 "between yields") \
1964 range(1, max_uintx) \
1965 \
1966 product(bool, CMSPrintChunksInDump, false, \
1967 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1968 "more detailed information about the free chunks") \
1969 \
1970 product(bool, CMSPrintObjectsInDump, false, \
1971 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1972 "more detailed information about the allocated objects") \
1973 \
1974 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
1975 "Verify that all references across the FLS boundary " \
1976 "are to valid objects") \
1977 \
1978 diagnostic(bool, FLSVerifyLists, false, \
1979 "Do lots of (expensive) FreeListSpace verification") \
1980 \
1981 diagnostic(bool, FLSVerifyIndexTable, false, \
1982 "Do lots of (expensive) FLS index table verification") \
1983 \
1984 develop(bool, FLSVerifyDictionary, false, \
1985 "Do lots of (expensive) FLS dictionary verification") \
1986 \
1987 develop(bool, VerifyBlockOffsetArray, false, \
1988 "Do (expensive) block offset array verification") \
1989 \
1990 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
1991 "Maintain _unallocated_block in BlockOffsetArray " \
1992 "(currently applicable only to CMS collector)") \
1993 \
1994 product(intx, RefDiscoveryPolicy, 0, \
1995 "Select type of reference discovery policy: " \
1996 "reference-based(0) or referent-based(1)") \
1997 range(ReferenceProcessor::DiscoveryPolicyMin, \
1998 ReferenceProcessor::DiscoveryPolicyMax) \
1999 \
2000 product(bool, ParallelRefProcEnabled, false, \
2001 "Enable parallel reference processing whenever possible") \
2002 \
2003 product(bool, ParallelRefProcBalancingEnabled, true, \
2004 "Enable balancing of reference processing queues") \
2005 \
2006 product(uintx, CMSTriggerRatio, 80, \
2007 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2008 "allocated before a CMS collection cycle commences") \
2009 range(0, 100) \
2010 \
2011 product(uintx, CMSBootstrapOccupancy, 50, \
2012 "Percentage CMS generation occupancy at which to " \
2013 "initiate CMS collection for bootstrapping collection stats") \
2037 product(uintx, CMSIsTooFullPercentage, 98, \
2038 "An absolute ceiling above which CMS will always consider the " \
2039 "unloading of classes when class unloading is enabled") \
2040 range(0, 100) \
2041 \
2042 notproduct(bool, CMSVerifyReturnedBytes, false, \
2043 "Check that all the garbage collected was returned to the " \
2044 "free lists") \
2045 \
2046 notproduct(bool, ScavengeALot, false, \
2047 "Force scavenge at every Nth exit from the runtime system " \
2048 "(N=ScavengeALotInterval)") \
2049 \
2050 develop(bool, FullGCALot, false, \
2051 "Force full gc at every Nth exit from the runtime system " \
2052 "(N=FullGCALotInterval)") \
2053 \
2054 notproduct(bool, GCALotAtAllSafepoints, false, \
2055 "Enforce ScavengeALot/GCALot at all potential safepoints") \
2056 \
2057 notproduct(bool, PromotionFailureALot, false, \
2058 "Use promotion failure handling on every youngest generation " \
2059 "collection") \
2060 \
2061 develop(uintx, PromotionFailureALotCount, 1000, \
2062 "Number of promotion failures occurring at PLAB " \
2063 "refill attempts (ParNew) or promotion attempts " \
2064 "(other young collectors)") \
2065 \
2066 develop(uintx, PromotionFailureALotInterval, 5, \
2067 "Total collections between promotion failures a lot") \
2068 \
2069 experimental(uintx, WorkStealingSleepMillis, 1, \
2070 "Sleep time when sleep is used for yields") \
2071 \
2072 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
2073 "Number of yields before a sleep is done during work stealing") \
2074 \
2075 experimental(uintx, WorkStealingHardSpins, 4096, \
2076 "Number of iterations in a spin loop between checks on " \
2077 "time out of hard spin") \
2078 \
2079 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
2080 "Ratio of hard spins to calls to yield") \
2081 \
2082 develop(uintx, ObjArrayMarkingStride, 512, \
2083 "Number of object array elements to push onto the marking stack " \
2084 "before pushing a continuation entry") \
2085 \
2086 develop(bool, MetadataAllocationFailALot, false, \
2087 "Fail metadata allocations at intervals controlled by " \
2088 "MetadataAllocationFailALotInterval") \
2089 \
2090 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
2091 "Metadata allocation failure a lot interval") \
2092 \
2093 develop(bool, TraceMetadataChunkAllocation, false, \
2094 "Trace chunk metadata allocations") \
2095 \
2096 notproduct(bool, ExecuteInternalVMTests, false, \
2097 "Enable execution of internal VM tests") \
2098 \
2099 notproduct(bool, VerboseInternalVMTests, false, \
2100 "Turn on logging for internal VM tests.") \
2101 \
2102 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
2103 \
2104 product_pd(bool, ResizeTLAB, \
2105 "Dynamically resize TLAB size for threads") \
2106 \
2107 product(bool, ZeroTLAB, false, \
2108 "Zero out the newly created TLAB") \
2109 \
2110 product(bool, FastTLABRefill, true, \
2111 "Use fast TLAB refill code") \
2112 \
2113 product(bool, TLABStats, true, \
2114 "Provide more detailed and expensive TLAB statistics.") \
2115 \
2116 product_pd(bool, NeverActAsServerClassMachine, \
2117 "Never act like a server-class machine") \
2118 \
2119 product(bool, AlwaysActAsServerClassMachine, false, \
2120 "Always act like a server-class machine") \
2121 \
2122 product_pd(uint64_t, MaxRAM, \
2123 "Real memory size (in bytes) used to set maximum heap size") \
2124 range(0, 0XFFFFFFFFFFFFFFFF) \
2125 \
2126 product(size_t, ErgoHeapSizeLimit, 0, \
2127 "Maximum ergonomically set heap size (in bytes); zero means use " \
2128 "MaxRAM / MaxRAMFraction") \
2129 \
2130 product(uintx, MaxRAMFraction, 4, \
2131 "Maximum fraction (1/n) of real memory used for maximum heap " \
2132 "size") \
2133 range(1, max_uintx) \
2134 \
2152 "Automatic GC selection pause threshold in milliseconds") \
2153 \
2154 product(bool, UseAdaptiveSizePolicy, true, \
2155 "Use adaptive generation sizing policies") \
2156 \
2157 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2158 "Use adaptive survivor sizing policies") \
2159 \
2160 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2161 "Use adaptive young-old sizing policies at minor collections") \
2162 \
2163 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2164 "Use adaptive young-old sizing policies at major collections") \
2165 \
2166 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2167 "Include statistics from System.gc() for adaptive size policy") \
2168 \
2169 product(bool, UseAdaptiveGCBoundary, false, \
2170 "Allow young-old boundary to move") \
2171 \
2172 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2173 "Resize the virtual spaces of the young or old generations") \
2174 range(-1, 1) \
2175 \
2176 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2177 "Policy for changing generation size for throughput goals") \
2178 range(0, 1) \
2179 \
2180 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2181 "Number of steps where heuristics is used before data is used") \
2182 \
2183 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2184 "Number of collections before the adaptive sizing is started") \
2185 \
2186 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2187 "Collection interval for printing information; zero means never") \
2188 \
2189 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2190 "Use adaptive minimum footprint as a goal") \
2191 \
2276 "Estimate of footprint other than Java Heap") \
2277 \
2278 product(bool, UseGCOverheadLimit, true, \
2279 "Use policy to limit of proportion of time spent in GC " \
2280 "before an OutOfMemory error is thrown") \
2281 \
2282 product(uintx, GCTimeLimit, 98, \
2283 "Limit of the proportion of time spent in GC before " \
2284 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2285 range(0, 100) \
2286 \
2287 product(uintx, GCHeapFreeLimit, 2, \
2288 "Minimum percentage of free space after a full GC before an " \
2289 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2290 range(0, 100) \
2291 \
2292 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2293 "Number of consecutive collections before gc time limit fires") \
2294 range(1, max_uintx) \
2295 \
2296 product(intx, PrefetchCopyIntervalInBytes, -1, \
2297 "How far ahead to prefetch destination area (<= 0 means off)") \
2298 \
2299 product(intx, PrefetchScanIntervalInBytes, -1, \
2300 "How far ahead to prefetch scan area (<= 0 means off)") \
2301 \
2302 product(intx, PrefetchFieldsAhead, -1, \
2303 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2304 \
2305 diagnostic(bool, VerifyDuringStartup, false, \
2306 "Verify memory system before executing any Java code " \
2307 "during VM initialization") \
2308 \
2309 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2310 "Verify system before exiting") \
2311 \
2312 diagnostic(bool, VerifyBeforeGC, false, \
2313 "Verify memory system before GC") \
2314 \
2315 diagnostic(bool, VerifyAfterGC, false, \
2316 "Verify memory system after GC") \
2317 \
2318 diagnostic(bool, VerifyDuringGC, false, \
2319 "Verify memory system during GC (between phases)") \
2320 \
2321 diagnostic(bool, GCParallelVerificationEnabled, true, \
2322 "Enable parallel memory system verification") \
2323 \
2324 diagnostic(bool, DeferInitialCardMark, false, \
2353 "Use worker affinity when asking for GCTasks") \
2354 \
2355 product(uintx, ProcessDistributionStride, 4, \
2356 "Stride through processors when distributing processes") \
2357 \
2358 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2359 "Number of times the coordinator GC thread will sleep while " \
2360 "yielding before giving up and resuming GC") \
2361 \
2362 product(uintx, CMSYieldSleepCount, 0, \
2363 "Number of times a GC thread (minus the coordinator) " \
2364 "will sleep while yielding before giving up and resuming GC") \
2365 \
2366 /* gc tracing */ \
2367 manageable(bool, PrintGC, false, \
2368 "Print message at garbage collection") \
2369 \
2370 manageable(bool, PrintGCDetails, false, \
2371 "Print more details at garbage collection") \
2372 \
2373 manageable(bool, PrintGCTimeStamps, false, \
2374 "Print timestamps at garbage collection") \
2375 \
2376 develop(intx, ConcGCYieldTimeout, 0, \
2377 "If non-zero, assert that GC threads yield within this " \
2378 "number of milliseconds") \
2379 range(0, max_intx) \
2380 \
2381 product(bool, PrintReferenceGC, false, \
2382 "Print times spent handling reference objects during GC " \
2383 "(enabled only when PrintGCDetails)") \
2384 \
2385 develop(bool, TraceFinalizerRegistration, false, \
2386 "Trace registration of final references") \
2387 \
2388 notproduct(bool, TraceScavenge, false, \
2389 "Trace scavenge") \
2390 \
2391 product(bool, IgnoreEmptyClassPaths, false, \
2392 "Ignore empty path elements in -classpath") \
2393 \
2394 product(bool, TraceClassPaths, false, \
2395 "Trace processing of class paths") \
2396 \
2397 product_rw(bool, TraceClassLoading, false, \
2398 "Trace all classes loaded") \
2399 \
2400 product(bool, TraceClassLoadingPreorder, false, \
2401 "Trace all classes loaded in order referenced (not loaded)") \
2402 \
2403 product_rw(bool, TraceClassUnloading, false, \
2404 "Trace unloading of classes") \
2405 \
2406 product_rw(bool, TraceLoaderConstraints, false, \
2407 "Trace loader constraints") \
2408 \
2409 develop(bool, TraceClassLoaderData, false, \
2410 "Trace class loader loader_data lifetime") \
2411 \
2412 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2413 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2414 "Initial size of the boot class loader data metaspace") \
2415 range(30*K, max_uintx/BytesPerWord) \
2416 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2417 \
2418 product(bool, TraceYoungGenTime, false, \
2419 "Trace accumulated time for young collection") \
2420 \
2421 product(bool, TraceOldGenTime, false, \
2422 "Trace accumulated time for old collection") \
2423 \
2424 product(bool, PrintHeapAtSIGBREAK, true, \
2425 "Print heap layout in response to SIGBREAK") \
2426 \
2427 manageable(bool, PrintClassHistogramAfterFullGC, false, \
2428 "Print a class histogram after any major stop-world GC") \
2429 \
2430 manageable(bool, PrintClassHistogram, false, \
2431 "Print a histogram of class instances") \
2432 \
2433 develop(bool, TraceWorkGang, false, \
2434 "Trace activities of work gangs") \
2435 \
2436 develop(bool, TraceGCTaskManager, false, \
2437 "Trace actions of the GC task manager") \
2438 \
2439 develop(bool, TraceGCTaskQueue, false, \
2440 "Trace actions of the GC task queues") \
2441 \
2442 diagnostic(bool, TraceGCTaskThread, false, \
2443 "Trace actions of the GC task threads") \
2444 \
2445 product(bool, PrintParallelOldGCPhaseTimes, false, \
2446 "Print the time taken by each phase in ParallelOldGC " \
2447 "(PrintGCDetails must also be enabled)") \
2448 \
2449 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2450 "Trace marking phase in ParallelOldGC") \
2451 \
2452 develop(bool, TraceParallelOldGCDensePrefix, false, \
2453 "Trace dense prefix computation for ParallelOldGC") \
2454 \
2455 develop(bool, IgnoreLibthreadGPFault, false, \
2456 "Suppress workaround for libthread GP fault") \
2457 \
2458 product(bool, PrintJNIGCStalls, false, \
2459 "Print diagnostic message when GC is stalled " \
2460 "by JNI critical section") \
2461 \
2462 experimental(double, ObjectCountCutOffPercent, 0.5, \
2463 "The percentage of the used heap that the instances of a class " \
2464 "must occupy for the class to generate a trace event") \
2465 range(0.0, 100.0) \
2466 \
2467 /* GC log rotation setting */ \
2468 \
2469 product(bool, UseGCLogFileRotation, false, \
2470 "Rotate gclog files (for long running applications). It requires "\
2471 "-Xloggc:<filename>") \
3372 \
3373 product(uintx, TargetSurvivorRatio, 50, \
3374 "Desired percentage of survivor space used after scavenge") \
3375 range(0, 100) \
3376 \
3377 product(uintx, MarkSweepDeadRatio, 5, \
3378 "Percentage (0-100) of the old gen allowed as dead wood. " \
3379 "Serial mark sweep treats this as both the minimum and maximum " \
3380 "value. " \
3381 "CMS uses this value only if it falls back to mark sweep. " \
3382 "Par compact uses a variable scale based on the density of the " \
3383 "generation and treats this as the maximum value when the heap " \
3384 "is either completely full or completely empty. Par compact " \
3385 "also has a smaller default value; see arguments.cpp.") \
3386 range(0, 100) \
3387 \
3388 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3389 "How often should we fully compact the heap (ignoring the dead " \
3390 "space parameters)") \
3391 range(1, max_uintx) \
3392 \
3393 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3394 "Delay between expansion and allocation (in milliseconds)") \
3395 \
3396 develop(uintx, GCWorkerDelayMillis, 0, \
3397 "Delay in scheduling GC workers (in milliseconds)") \
3398 \
3399 product(intx, DeferThrSuspendLoopCount, 4000, \
3400 "(Unstable) Number of times to iterate in safepoint loop " \
3401 "before blocking VM threads ") \
3402 range(-1, max_jint-1) \
3403 \
3404 product(intx, DeferPollingPageLoopCount, -1, \
3405 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3406 "before changing safepoint polling page to RO ") \
3407 range(-1, max_jint-1) \
3408 \
3409 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3410 range(0, max_intx) \
3411 \
|