968 "Print all malloc/free calls") \
969 \
970 develop(bool, PrintMallocStatistics, false, \
971 "Print malloc/free statistics") \
972 \
973 develop(bool, ZapResourceArea, trueInDebug, \
974 "Zap freed resource/arena space with 0xABABABAB") \
975 \
976 notproduct(bool, ZapVMHandleArea, trueInDebug, \
977 "Zap freed VM handle space with 0xBCBCBCBC") \
978 \
979 develop(bool, ZapJNIHandleArea, trueInDebug, \
980 "Zap freed JNI handle space with 0xFEFEFEFE") \
981 \
982 notproduct(bool, ZapStackSegments, trueInDebug, \
983 "Zap allocated/freed stack segments with 0xFADFADED") \
984 \
985 develop(bool, ZapUnusedHeapArea, trueInDebug, \
986 "Zap unused heap space with 0xBAADBABE") \
987 \
988 develop(bool, TraceZapUnusedHeapArea, false, \
989 "Trace zapping of unused heap space") \
990 \
991 develop(bool, CheckZapUnusedHeapArea, false, \
992 "Check zapping of unused heap space") \
993 \
994 develop(bool, ZapFillerObjects, trueInDebug, \
995 "Zap filler objects with 0xDEAFBABE") \
996 \
997 develop(bool, PrintVMMessages, true, \
998 "Print VM messages on console") \
999 \
1000 product(bool, PrintGCApplicationConcurrentTime, false, \
1001 "Print the time the application has been running") \
1002 \
1003 product(bool, PrintGCApplicationStoppedTime, false, \
1004 "Print the time the application has been stopped") \
1005 \
1006 diagnostic(bool, VerboseVerification, false, \
1007 "Display detailed verification details") \
1008 \
1009 notproduct(uintx, ErrorHandlerTest, 0, \
1010 "If > 0, provokes an error after VM initialization; the value " \
1011 "determines which error to provoke. See test_error_handler() " \
1012 "in debug.cpp.") \
1013 \
1014 notproduct(uintx, TestCrashInErrorHandler, 0, \
1015 "If > 0, provokes an error inside VM error handler (a secondary " \
1016 "crash). see test_error_handler() in debug.cpp.") \
1017 \
1018 notproduct(bool, TestSafeFetchInErrorHandler, false, \
1019 "If true, tests SafeFetch inside error handler.") \
1020 \
1021 develop(bool, Verbose, false, \
1022 "Print additional debugging information from other modes") \
1023 \
1024 develop(bool, PrintMiscellaneous, false, \
1025 "Print uncategorized debugging information (requires +Verbose)") \
1559 "Number of parallel threads parallel gc will use") \
1560 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1561 \
1562 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1563 "Use semaphore synchronization for the GC Threads, " \
1564 "instead of synchronization based on mutexes") \
1565 \
1566 product(bool, UseDynamicNumberOfGCThreads, false, \
1567 "Dynamically choose the number of parallel threads " \
1568 "parallel gc will use") \
1569 \
1570 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1571 "Force dynamic selection of the number of " \
1572 "parallel threads parallel gc will use to aid debugging") \
1573 \
1574 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1575 "Size of heap (bytes) per GC thread used in calculating the " \
1576 "number of GC threads") \
1577 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1578 \
1579 product(bool, TraceDynamicGCThreads, false, \
1580 "Trace the dynamic GC thread usage") \
1581 \
1582 product(uint, ConcGCThreads, 0, \
1583 "Number of threads concurrent gc will use") \
1584 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1585 \
1586 product(uintx, GCTaskTimeStampEntries, 200, \
1587 "Number of time stamp entries per gc worker thread") \
1588 range(1, max_uintx) \
1589 \
1590 product(bool, AlwaysTenure, false, \
1591 "Always tenure objects in eden (ParallelGC only)") \
1592 \
1593 product(bool, NeverTenure, false, \
1594 "Never tenure objects in eden, may tenure on overflow " \
1595 "(ParallelGC only)") \
1596 \
1597 product(bool, ScavengeBeforeFullGC, true, \
1598 "Scavenge youngest generation before each full GC.") \
1599 \
1600 product(bool, UseConcMarkSweepGC, false, \
1601 "Use Concurrent Mark-Sweep GC in the old generation") \
1612 product(bool, GCLockerInvokesConcurrent, false, \
1613 "The exit of a JNI critical section necessitating a scavenge, " \
1614 "also kicks off a background concurrent collection") \
1615 \
1616 product(uintx, GCLockerEdenExpansionPercent, 5, \
1617 "How much the GC can expand the eden by while the GC locker " \
1618 "is active (as a percentage)") \
1619 range(0, 100) \
1620 \
1621 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1622 "Number of times to retry allocations when " \
1623 "blocked by the GC locker") \
1624 range(0, max_uintx) \
1625 \
1626 product(bool, UseCMSBestFit, true, \
1627 "Use CMS best fit allocation strategy") \
1628 \
1629 product(bool, UseParNewGC, false, \
1630 "Use parallel threads in the new generation") \
1631 \
1632 product(bool, PrintTaskqueue, false, \
1633 "Print taskqueue statistics for parallel collectors") \
1634 \
1635 product(bool, PrintTerminationStats, false, \
1636 "Print termination statistics for parallel collectors") \
1637 \
1638 product(uintx, ParallelGCBufferWastePct, 10, \
1639 "Wasted fraction of parallel allocation buffer") \
1640 range(0, 100) \
1641 \
1642 product(uintx, TargetPLABWastePct, 10, \
1643 "Target wasted space in last buffer as percent of overall " \
1644 "allocation") \
1645 range(1, 100) \
1646 \
1647 product(uintx, PLABWeight, 75, \
1648 "Percentage (0-100) used to weight the current sample when " \
1649 "computing exponentially decaying average for ResizePLAB") \
1650 range(0, 100) \
1651 \
1652 product(bool, ResizePLAB, true, \
1653 "Dynamically resize (survivor space) promotion LAB's") \
1654 \
1655 product(bool, PrintPLAB, false, \
1656 "Print (survivor space) promotion LAB's sizing decisions") \
1657 \
1658 product(intx, ParGCArrayScanChunk, 50, \
1659 "Scan a subset of object array and push remainder, if array is " \
1660 "bigger than this") \
1661 range(1, max_intx) \
1662 \
1663 product(bool, ParGCUseLocalOverflow, false, \
1664 "Instead of a global overflow list, use local overflow stacks") \
1665 \
1666 product(bool, ParGCTrimOverflow, true, \
1667 "Eagerly trim the local overflow lists " \
1668 "(when ParGCUseLocalOverflow)") \
1669 \
1670 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1671 "Simulate work queue overflow in ParNew") \
1672 \
1673 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1674 "An `interval' counter that determines how frequently " \
1675 "we simulate overflow; a smaller number increases frequency") \
1676 \
1677 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1681 diagnostic(uintx, ParGCStridesPerThread, 2, \
1682 "The number of strides per worker thread that we divide up the " \
1683 "card table scanning work into") \
1684 range(1, max_uintx) \
1685 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1686 \
1687 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1688 "The number of cards in each chunk of the parallel chunks used " \
1689 "during card table scanning") \
1690 range(1, max_intx) \
1691 \
1692 product(uintx, OldPLABWeight, 50, \
1693 "Percentage (0-100) used to weight the current sample when " \
1694 "computing exponentially decaying average for resizing " \
1695 "OldPLABSize") \
1696 range(0, 100) \
1697 \
1698 product(bool, ResizeOldPLAB, true, \
1699 "Dynamically resize (old gen) promotion LAB's") \
1700 \
1701 product(bool, PrintOldPLAB, false, \
1702 "Print (old gen) promotion LAB's sizing decisions") \
1703 \
1704 product(size_t, CMSOldPLABMax, 1024, \
1705 "Maximum size of CMS gen promotion LAB caches per worker " \
1706 "per block size") \
1707 range(1, max_uintx) \
1708 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1709 \
1710 product(size_t, CMSOldPLABMin, 16, \
1711 "Minimum size of CMS gen promotion LAB caches per worker " \
1712 "per block size") \
1713 range(1, max_uintx) \
1714 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1715 \
1716 product(uintx, CMSOldPLABNumRefills, 4, \
1717 "Nominal number of refills of CMS gen promotion LAB cache " \
1718 "per worker per block size") \
1719 range(1, max_uintx) \
1720 \
1721 product(bool, CMSOldPLABResizeQuicker, false, \
1722 "React on-the-fly during a scavenge to a sudden " \
1723 "change in block demand rate") \
1882 "Whether abort-on-overflow semantics is implemented") \
1883 \
1884 product(bool, CMSParallelInitialMarkEnabled, true, \
1885 "Use the parallel initial mark.") \
1886 \
1887 product(bool, CMSParallelRemarkEnabled, true, \
1888 "Whether parallel remark enabled (only if ParNewGC)") \
1889 \
1890 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1891 "Whether parallel remark of survivor space " \
1892 "enabled (effective only if CMSParallelRemarkEnabled)") \
1893 \
1894 product(bool, CMSPLABRecordAlways, true, \
1895 "Always record survivor space PLAB boundaries (effective only " \
1896 "if CMSParallelSurvivorRemarkEnabled)") \
1897 \
1898 product(bool, CMSEdenChunksRecordAlways, true, \
1899 "Always record eden chunks used for the parallel initial mark " \
1900 "or remark of eden") \
1901 \
1902 product(bool, CMSPrintEdenSurvivorChunks, false, \
1903 "Print the eden and the survivor chunks used for the parallel " \
1904 "initial mark or remark of the eden/survivor spaces") \
1905 \
1906 product(bool, CMSConcurrentMTEnabled, true, \
1907 "Whether multi-threaded concurrent work enabled " \
1908 "(effective only if ParNewGC)") \
1909 \
1910 product(bool, CMSPrecleaningEnabled, true, \
1911 "Whether concurrent precleaning enabled") \
1912 \
1913 product(uintx, CMSPrecleanIter, 3, \
1914 "Maximum number of precleaning iteration passes") \
1915 range(0, 9) \
1916 \
1917 product(uintx, CMSPrecleanDenominator, 3, \
1918 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1919 "ratio") \
1920 range(1, max_uintx) \
1921 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1922 \
1923 product(uintx, CMSPrecleanNumerator, 2, \
1924 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1925 "ratio") \
1954 range(0, max_uintx) \
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 range(min_jint, max_jint) \
1985 \
1986 develop(uintx, CMSCheckInterval, 1000, \
1987 "Interval in milliseconds that CMS thread checks if it " \
1988 "should start a collection cycle") \
1989 \
1990 product(bool, CMSYield, true, \
1991 "Yield between steps of CMS") \
1992 \
1993 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1994 "Bitmap operations should process at most this many bits " \
1995 "between yields") \
1996 range(1, max_uintx) \
1997 \
1998 product(bool, CMSDumpAtPromotionFailure, false, \
1999 "Dump useful information about the state of the CMS old " \
2000 "generation upon a promotion failure") \
2001 \
2002 product(bool, CMSPrintChunksInDump, false, \
2003 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
2004 "more detailed information about the free chunks") \
2005 \
2006 product(bool, CMSPrintObjectsInDump, false, \
2007 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
2008 "more detailed information about the allocated objects") \
2009 \
2010 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
2011 "Verify that all references across the FLS boundary " \
2012 "are to valid objects") \
2013 \
2014 diagnostic(bool, FLSVerifyLists, false, \
2015 "Do lots of (expensive) FreeListSpace verification") \
2016 \
2017 diagnostic(bool, FLSVerifyIndexTable, false, \
2018 "Do lots of (expensive) FLS index table verification") \
2019 \
2020 develop(bool, FLSVerifyDictionary, false, \
2021 "Do lots of (expensive) FLS dictionary verification") \
2022 \
2023 develop(bool, VerifyBlockOffsetArray, false, \
2024 "Do (expensive) block offset array verification") \
2025 \
2026 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
2027 "Maintain _unallocated_block in BlockOffsetArray " \
2028 "(currently applicable only to CMS collector)") \
2029 \
2030 develop(bool, TraceCMSState, false, \
2031 "Trace the state of the CMS collection") \
2032 \
2033 product(intx, RefDiscoveryPolicy, 0, \
2034 "Select type of reference discovery policy: " \
2035 "reference-based(0) or referent-based(1)") \
2036 range(ReferenceProcessor::DiscoveryPolicyMin, \
2037 ReferenceProcessor::DiscoveryPolicyMax) \
2038 \
2039 product(bool, ParallelRefProcEnabled, false, \
2040 "Enable parallel reference processing whenever possible") \
2041 \
2042 product(bool, ParallelRefProcBalancingEnabled, true, \
2043 "Enable balancing of reference processing queues") \
2044 \
2045 product(uintx, CMSTriggerRatio, 80, \
2046 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2047 "allocated before a CMS collection cycle commences") \
2048 range(0, 100) \
2049 \
2050 product(uintx, CMSBootstrapOccupancy, 50, \
2051 "Percentage CMS generation occupancy at which to " \
2052 "initiate CMS collection for bootstrapping collection stats") \
2080 \
2081 develop(bool, CMSTestInFreeList, false, \
2082 "Check if the coalesced range is already in the " \
2083 "free lists as claimed") \
2084 \
2085 notproduct(bool, CMSVerifyReturnedBytes, false, \
2086 "Check that all the garbage collected was returned to the " \
2087 "free lists") \
2088 \
2089 notproduct(bool, ScavengeALot, false, \
2090 "Force scavenge at every Nth exit from the runtime system " \
2091 "(N=ScavengeALotInterval)") \
2092 \
2093 develop(bool, FullGCALot, false, \
2094 "Force full gc at every Nth exit from the runtime system " \
2095 "(N=FullGCALotInterval)") \
2096 \
2097 notproduct(bool, GCALotAtAllSafepoints, false, \
2098 "Enforce ScavengeALot/GCALot at all potential safepoints") \
2099 \
2100 product(bool, PrintPromotionFailure, false, \
2101 "Print additional diagnostic information following " \
2102 "promotion failure") \
2103 \
2104 notproduct(bool, PromotionFailureALot, false, \
2105 "Use promotion failure handling on every youngest generation " \
2106 "collection") \
2107 \
2108 develop(uintx, PromotionFailureALotCount, 1000, \
2109 "Number of promotion failures occurring at PLAB " \
2110 "refill attempts (ParNew) or promotion attempts " \
2111 "(other young collectors)") \
2112 \
2113 develop(uintx, PromotionFailureALotInterval, 5, \
2114 "Total collections between promotion failures a lot") \
2115 \
2116 experimental(uintx, WorkStealingSleepMillis, 1, \
2117 "Sleep time when sleep is used for yields") \
2118 \
2119 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
2120 "Number of yields before a sleep is done during work stealing") \
2121 \
2122 experimental(uintx, WorkStealingHardSpins, 4096, \
2123 "Number of iterations in a spin loop between checks on " \
2124 "time out of hard spin") \
2125 \
2126 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
2127 "Ratio of hard spins to calls to yield") \
2128 \
2129 develop(uintx, ObjArrayMarkingStride, 512, \
2130 "Number of object array elements to push onto the marking stack " \
2131 "before pushing a continuation entry") \
2132 \
2133 develop(bool, MetadataAllocationFailALot, false, \
2134 "Fail metadata allocations at intervals controlled by " \
2135 "MetadataAllocationFailALotInterval") \
2136 \
2137 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
2138 "Metadata allocation failure a lot interval") \
2139 \
2140 develop(bool, TraceMetadataChunkAllocation, false, \
2141 "Trace chunk metadata allocations") \
2142 \
2143 product(bool, TraceMetadataHumongousAllocation, false, \
2144 "Trace humongous metadata allocations") \
2145 \
2146 develop(bool, TraceMetavirtualspaceAllocation, false, \
2147 "Trace virtual space metadata allocations") \
2148 \
2149 notproduct(bool, ExecuteInternalVMTests, false, \
2150 "Enable execution of internal VM tests") \
2151 \
2152 notproduct(bool, VerboseInternalVMTests, false, \
2153 "Turn on logging for internal VM tests.") \
2154 \
2155 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
2156 \
2157 product_pd(bool, ResizeTLAB, \
2158 "Dynamically resize TLAB size for threads") \
2159 \
2160 product(bool, ZeroTLAB, false, \
2161 "Zero out the newly created TLAB") \
2162 \
2163 product(bool, FastTLABRefill, true, \
2164 "Use fast TLAB refill code") \
2165 \
2166 product(bool, PrintTLAB, false, \
2167 "Print various TLAB related information") \
2168 \
2169 product(bool, TLABStats, true, \
2170 "Provide more detailed and expensive TLAB statistics " \
2171 "(with PrintTLAB)") \
2172 \
2173 product_pd(bool, NeverActAsServerClassMachine, \
2174 "Never act like a server-class machine") \
2175 \
2176 product(bool, AlwaysActAsServerClassMachine, false, \
2177 "Always act like a server-class machine") \
2178 \
2179 product_pd(uint64_t, MaxRAM, \
2180 "Real memory size (in bytes) used to set maximum heap size") \
2181 range(0, 0XFFFFFFFFFFFFFFFF) \
2182 \
2183 product(size_t, ErgoHeapSizeLimit, 0, \
2184 "Maximum ergonomically set heap size (in bytes); zero means use " \
2185 "MaxRAM / MaxRAMFraction") \
2186 range(0, max_uintx) \
2187 \
2188 product(uintx, MaxRAMFraction, 4, \
2189 "Maximum fraction (1/n) of real memory used for maximum heap " \
2190 "size") \
2191 range(1, max_uintx) \
2211 range(0, max_uintx) \
2212 \
2213 product(bool, UseAdaptiveSizePolicy, true, \
2214 "Use adaptive generation sizing policies") \
2215 \
2216 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2217 "Use adaptive survivor sizing policies") \
2218 \
2219 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2220 "Use adaptive young-old sizing policies at minor collections") \
2221 \
2222 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2223 "Use adaptive young-old sizing policies at major collections") \
2224 \
2225 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2226 "Include statistics from System.gc() for adaptive size policy") \
2227 \
2228 product(bool, UseAdaptiveGCBoundary, false, \
2229 "Allow young-old boundary to move") \
2230 \
2231 develop(bool, TraceAdaptiveGCBoundary, false, \
2232 "Trace young-old boundary moves") \
2233 \
2234 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2235 "Resize the virtual spaces of the young or old generations") \
2236 range(-1, 1) \
2237 \
2238 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2239 "Policy for changing generation size for throughput goals") \
2240 range(0, 1) \
2241 \
2242 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2243 "Number of steps where heuristics is used before data is used") \
2244 range(0, max_uintx) \
2245 \
2246 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2247 "Number of collections before the adaptive sizing is started") \
2248 \
2249 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2250 "Collection interval for printing information; zero means never") \
2251 range(0, max_uintx) \
2252 \
2253 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2349 range(0, max_uintx) \
2350 \
2351 product(bool, UseGCOverheadLimit, true, \
2352 "Use policy to limit of proportion of time spent in GC " \
2353 "before an OutOfMemory error is thrown") \
2354 \
2355 product(uintx, GCTimeLimit, 98, \
2356 "Limit of the proportion of time spent in GC before " \
2357 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2358 range(0, 100) \
2359 \
2360 product(uintx, GCHeapFreeLimit, 2, \
2361 "Minimum percentage of free space after a full GC before an " \
2362 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2363 range(0, 100) \
2364 \
2365 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2366 "Number of consecutive collections before gc time limit fires") \
2367 range(1, max_uintx) \
2368 \
2369 product(bool, PrintAdaptiveSizePolicy, false, \
2370 "Print information about AdaptiveSizePolicy") \
2371 \
2372 product(intx, PrefetchCopyIntervalInBytes, -1, \
2373 "How far ahead to prefetch destination area (<= 0 means off)") \
2374 range(-1, max_jint) \
2375 \
2376 product(intx, PrefetchScanIntervalInBytes, -1, \
2377 "How far ahead to prefetch scan area (<= 0 means off)") \
2378 range(-1, max_jint) \
2379 \
2380 product(intx, PrefetchFieldsAhead, -1, \
2381 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2382 range(-1, max_jint) \
2383 \
2384 diagnostic(bool, VerifySilently, false, \
2385 "Do not print the verification progress") \
2386 \
2387 diagnostic(bool, VerifyDuringStartup, false, \
2388 "Verify memory system before executing any Java code " \
2389 "during VM initialization") \
2390 \
2391 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2392 "Verify system before exiting") \
2393 \
2394 diagnostic(bool, VerifyBeforeGC, false, \
2395 "Verify memory system before GC") \
2396 \
2397 diagnostic(bool, VerifyAfterGC, false, \
2398 "Verify memory system after GC") \
2399 \
2400 diagnostic(bool, VerifyDuringGC, false, \
2401 "Verify memory system during GC (between phases)") \
2402 \
2403 diagnostic(bool, GCParallelVerificationEnabled, true, \
2404 "Enable parallel memory system verification") \
2405 \
2406 diagnostic(bool, DeferInitialCardMark, false, \
2432 product(bool, BindGCTaskThreadsToCPUs, false, \
2433 "Bind GCTaskThreads to CPUs if possible") \
2434 \
2435 product(bool, UseGCTaskAffinity, false, \
2436 "Use worker affinity when asking for GCTasks") \
2437 \
2438 product(uintx, ProcessDistributionStride, 4, \
2439 "Stride through processors when distributing processes") \
2440 range(0, max_juint) \
2441 \
2442 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2443 "Number of times the coordinator GC thread will sleep while " \
2444 "yielding before giving up and resuming GC") \
2445 range(0, max_juint) \
2446 \
2447 product(uintx, CMSYieldSleepCount, 0, \
2448 "Number of times a GC thread (minus the coordinator) " \
2449 "will sleep while yielding before giving up and resuming GC") \
2450 range(0, max_juint) \
2451 \
2452 /* gc tracing */ \
2453 manageable(bool, PrintGC, false, \
2454 "Print message at garbage collection") \
2455 \
2456 manageable(bool, PrintGCDetails, false, \
2457 "Print more details at garbage collection") \
2458 \
2459 manageable(bool, PrintGCDateStamps, false, \
2460 "Print date stamps at garbage collection") \
2461 \
2462 manageable(bool, PrintGCTimeStamps, false, \
2463 "Print timestamps at garbage collection") \
2464 \
2465 manageable(bool, PrintGCID, true, \
2466 "Print an identifier for each garbage collection") \
2467 \
2468 product(bool, PrintGCTaskTimeStamps, false, \
2469 "Print timestamps for individual gc worker thread tasks") \
2470 \
2471 develop(intx, ConcGCYieldTimeout, 0, \
2472 "If non-zero, assert that GC threads yield within this " \
2473 "number of milliseconds") \
2474 range(0, max_intx) \
2475 \
2476 product(bool, PrintReferenceGC, false, \
2477 "Print times spent handling reference objects during GC " \
2478 "(enabled only when PrintGCDetails)") \
2479 \
2480 develop(bool, TraceReferenceGC, false, \
2481 "Trace handling of soft/weak/final/phantom references") \
2482 \
2483 develop(bool, TraceFinalizerRegistration, false, \
2484 "Trace registration of final references") \
2485 \
2486 notproduct(bool, TraceScavenge, false, \
2487 "Trace scavenge") \
2488 \
2489 product(bool, IgnoreEmptyClassPaths, false, \
2490 "Ignore empty path elements in -classpath") \
2491 \
2492 product(bool, TraceClassPaths, false, \
2493 "Trace processing of class paths") \
2494 \
2495 product_rw(bool, TraceClassLoading, false, \
2496 "Trace all classes loaded") \
2497 \
2498 product(bool, TraceClassLoadingPreorder, false, \
2499 "Trace all classes loaded in order referenced (not loaded)") \
2500 \
2501 product_rw(bool, TraceClassUnloading, false, \
2502 "Trace unloading of classes") \
2503 \
2504 product_rw(bool, TraceLoaderConstraints, false, \
2505 "Trace loader constraints") \
2506 \
2507 develop(bool, TraceClassLoaderData, false, \
2508 "Trace class loader loader_data lifetime") \
2509 \
2510 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2511 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2512 "Initial size of the boot class loader data metaspace") \
2513 range(30*K, max_uintx/BytesPerWord) \
2514 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2515 \
2516 product(bool, TraceYoungGenTime, false, \
2517 "Trace accumulated time for young collection") \
2518 \
2519 product(bool, TraceOldGenTime, false, \
2520 "Trace accumulated time for old collection") \
2521 \
2522 product(bool, PrintTenuringDistribution, false, \
2523 "Print tenuring age information") \
2524 \
2525 product_rw(bool, PrintHeapAtGC, false, \
2526 "Print heap layout before and after each GC") \
2527 \
2528 product_rw(bool, PrintHeapAtGCExtended, false, \
2529 "Print extended information about the layout of the heap " \
2530 "when -XX:+PrintHeapAtGC is set") \
2531 \
2532 product(bool, PrintHeapAtSIGBREAK, true, \
2533 "Print heap layout in response to SIGBREAK") \
2534 \
2535 manageable(bool, PrintClassHistogramBeforeFullGC, false, \
2536 "Print a class histogram before any major stop-world GC") \
2537 \
2538 manageable(bool, PrintClassHistogramAfterFullGC, false, \
2539 "Print a class histogram after any major stop-world GC") \
2540 \
2541 manageable(bool, PrintClassHistogram, false, \
2542 "Print a histogram of class instances") \
2543 \
2544 develop(bool, TraceWorkGang, false, \
2545 "Trace activities of work gangs") \
2546 \
2547 develop(bool, TraceBlockOffsetTable, false, \
2548 "Print BlockOffsetTable maps") \
2549 \
2550 develop(bool, TraceCardTableModRefBS, false, \
2551 "Print CardTableModRefBS maps") \
2552 \
2553 develop(bool, TraceGCTaskManager, false, \
2554 "Trace actions of the GC task manager") \
2555 \
2556 develop(bool, TraceGCTaskQueue, false, \
2557 "Trace actions of the GC task queues") \
2558 \
2559 diagnostic(bool, TraceGCTaskThread, false, \
2560 "Trace actions of the GC task threads") \
2561 \
2562 product(bool, PrintParallelOldGCPhaseTimes, false, \
2563 "Print the time taken by each phase in ParallelOldGC " \
2564 "(PrintGCDetails must also be enabled)") \
2565 \
2566 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2567 "Trace marking phase in ParallelOldGC") \
2568 \
2569 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2570 "Trace summary phase in ParallelOldGC") \
2571 \
2572 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2573 "Trace compaction phase in ParallelOldGC") \
2574 \
2575 develop(bool, TraceParallelOldGCDensePrefix, false, \
2576 "Trace dense prefix computation for ParallelOldGC") \
2577 \
2578 develop(bool, IgnoreLibthreadGPFault, false, \
2579 "Suppress workaround for libthread GP fault") \
2580 \
2581 product(bool, PrintJNIGCStalls, false, \
2582 "Print diagnostic message when GC is stalled " \
2583 "by JNI critical section") \
2584 \
2585 experimental(double, ObjectCountCutOffPercent, 0.5, \
2586 "The percentage of the used heap that the instances of a class " \
2587 "must occupy for the class to generate a trace event") \
2588 range(0.0, 100.0) \
2589 \
2590 /* GC log rotation setting */ \
2591 \
2592 product(bool, UseGCLogFileRotation, false, \
2593 "Rotate gclog files (for long running applications). It requires "\
2594 "-Xloggc:<filename>") \
2595 \
2596 product(uintx, NumberOfGCLogFiles, 0, \
2597 "Number of gclog files in rotation " \
2598 "(default: 0, no rotation)") \
2599 range(0, max_uintx) \
2600 \
2601 product(size_t, GCLogFileSize, 8*K, \
2602 "GC log file size, requires UseGCLogFileRotation. " \
2603 "Set to 0 to only trigger rotation via jcmd") \
2604 range(0, max_uintx) \
2605 \
2606 /* JVMTI heap profiling */ \
2607 \
2608 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2609 "Trace JVMTI object tagging calls") \
2610 \
2611 diagnostic(bool, VerifyBeforeIteration, false, \
2612 "Verify memory system before JVMTI iteration") \
2613 \
2614 /* compiler interface */ \
2615 \
2616 develop(bool, CIPrintCompilerName, false, \
2617 "when CIPrint is active, print the name of the active compiler") \
2618 \
2619 diagnostic(bool, CIPrintCompileQueue, false, \
2620 "display the contents of the compile queue whenever a " \
2621 "compilation is enqueued") \
2622 \
2623 develop(bool, CIPrintRequests, false, \
2624 "display every request for compilation") \
2625 \
3522 product(uintx, TargetSurvivorRatio, 50, \
3523 "Desired percentage of survivor space used after scavenge") \
3524 range(0, 100) \
3525 \
3526 product(uintx, MarkSweepDeadRatio, 5, \
3527 "Percentage (0-100) of the old gen allowed as dead wood. " \
3528 "Serial mark sweep treats this as both the minimum and maximum " \
3529 "value. " \
3530 "CMS uses this value only if it falls back to mark sweep. " \
3531 "Par compact uses a variable scale based on the density of the " \
3532 "generation and treats this as the maximum value when the heap " \
3533 "is either completely full or completely empty. Par compact " \
3534 "also has a smaller default value; see arguments.cpp.") \
3535 range(0, 100) \
3536 \
3537 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3538 "How often should we fully compact the heap (ignoring the dead " \
3539 "space parameters)") \
3540 range(1, max_uintx) \
3541 \
3542 product(intx, PrintCMSStatistics, 0, \
3543 "Statistics for CMS") \
3544 range(0, 2) \
3545 \
3546 product(bool, PrintCMSInitiationStatistics, false, \
3547 "Statistics for initiating a CMS collection") \
3548 \
3549 product(intx, PrintFLSStatistics, 0, \
3550 "Statistics for CMS' FreeListSpace") \
3551 range(0, 2) \
3552 \
3553 product(intx, PrintFLSCensus, 0, \
3554 "Census for CMS' FreeListSpace") \
3555 range(0, 1) \
3556 \
3557 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3558 "Delay between expansion and allocation (in milliseconds)") \
3559 \
3560 develop(uintx, GCWorkerDelayMillis, 0, \
3561 "Delay in scheduling GC workers (in milliseconds)") \
3562 \
3563 product(intx, DeferThrSuspendLoopCount, 4000, \
3564 "(Unstable) Number of times to iterate in safepoint loop " \
3565 "before blocking VM threads ") \
3566 range(-1, max_jint-1) \
3567 \
3568 product(intx, DeferPollingPageLoopCount, -1, \
3569 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3570 "before changing safepoint polling page to RO ") \
3571 range(-1, max_jint-1) \
3572 \
3573 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3574 range(0, max_intx) \
3575 \
3576 product(bool, PSChunkLargeArrays, true, \
4231 product(bool, DTraceAllocProbes, false, \
4232 "Enable dtrace probes for object allocation") \
4233 \
4234 product(bool, DTraceMonitorProbes, false, \
4235 "Enable dtrace probes for monitor events") \
4236 \
4237 product(bool, RelaxAccessControlCheck, false, \
4238 "Relax the access control checks in the verifier") \
4239 \
4240 product(uintx, StringTableSize, defaultStringTableSize, \
4241 "Number of buckets in the interned String table") \
4242 range(minimumStringTableSize, 111*defaultStringTableSize) \
4243 \
4244 experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
4245 "Number of buckets in the JVM internal Symbol table") \
4246 range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \
4247 \
4248 product(bool, UseStringDeduplication, false, \
4249 "Use string deduplication") \
4250 \
4251 product(bool, PrintStringDeduplicationStatistics, false, \
4252 "Print string deduplication statistics") \
4253 \
4254 product(uintx, StringDeduplicationAgeThreshold, 3, \
4255 "A string must reach this age (or be promoted to an old region) " \
4256 "to be considered for deduplication") \
4257 range(1, markOopDesc::max_age) \
4258 \
4259 diagnostic(bool, StringDeduplicationResizeALot, false, \
4260 "Force table resize every time the table is scanned") \
4261 \
4262 diagnostic(bool, StringDeduplicationRehashALot, false, \
4263 "Force table rehash every time the table is scanned") \
4264 \
4265 diagnostic(bool, WhiteBoxAPI, false, \
4266 "Enable internal testing APIs") \
4267 \
4268 product(bool, PrintGCCause, true, \
4269 "Include GC cause in GC logging") \
4270 \
4271 experimental(intx, SurvivorAlignmentInBytes, 0, \
4272 "Default survivor space alignment in bytes") \
4273 constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \
4274 \
4275 product(bool , AllowNonVirtualCalls, false, \
4276 "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
4277 \
4278 product(ccstr, DumpLoadedClassList, NULL, \
4279 "Dump the names all loaded classes, that could be stored into " \
4280 "the CDS archive, in the specified file") \
4281 \
4282 product(ccstr, SharedClassListFile, NULL, \
4283 "Override the default CDS class list") \
4284 \
4285 diagnostic(ccstr, SharedArchiveFile, NULL, \
4286 "Override the default location of the CDS archive file") \
4287 \
4288 product(ccstr, ExtraSharedClassListFile, NULL, \
4289 "Extra classlist for building the CDS archive file") \
|
968 "Print all malloc/free calls") \
969 \
970 develop(bool, PrintMallocStatistics, false, \
971 "Print malloc/free statistics") \
972 \
973 develop(bool, ZapResourceArea, trueInDebug, \
974 "Zap freed resource/arena space with 0xABABABAB") \
975 \
976 notproduct(bool, ZapVMHandleArea, trueInDebug, \
977 "Zap freed VM handle space with 0xBCBCBCBC") \
978 \
979 develop(bool, ZapJNIHandleArea, trueInDebug, \
980 "Zap freed JNI handle space with 0xFEFEFEFE") \
981 \
982 notproduct(bool, ZapStackSegments, trueInDebug, \
983 "Zap allocated/freed stack segments with 0xFADFADED") \
984 \
985 develop(bool, ZapUnusedHeapArea, trueInDebug, \
986 "Zap unused heap space with 0xBAADBABE") \
987 \
988 develop(bool, CheckZapUnusedHeapArea, false, \
989 "Check zapping of unused heap space") \
990 \
991 develop(bool, ZapFillerObjects, trueInDebug, \
992 "Zap filler objects with 0xDEAFBABE") \
993 \
994 develop(bool, PrintVMMessages, true, \
995 "Print VM messages on console") \
996 \
997 diagnostic(bool, VerboseVerification, false, \
998 "Display detailed verification details") \
999 \
1000 notproduct(uintx, ErrorHandlerTest, 0, \
1001 "If > 0, provokes an error after VM initialization; the value " \
1002 "determines which error to provoke. See test_error_handler() " \
1003 "in debug.cpp.") \
1004 \
1005 notproduct(uintx, TestCrashInErrorHandler, 0, \
1006 "If > 0, provokes an error inside VM error handler (a secondary " \
1007 "crash). see test_error_handler() in debug.cpp.") \
1008 \
1009 notproduct(bool, TestSafeFetchInErrorHandler, false, \
1010 "If true, tests SafeFetch inside error handler.") \
1011 \
1012 develop(bool, Verbose, false, \
1013 "Print additional debugging information from other modes") \
1014 \
1015 develop(bool, PrintMiscellaneous, false, \
1016 "Print uncategorized debugging information (requires +Verbose)") \
1550 "Number of parallel threads parallel gc will use") \
1551 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1552 \
1553 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1554 "Use semaphore synchronization for the GC Threads, " \
1555 "instead of synchronization based on mutexes") \
1556 \
1557 product(bool, UseDynamicNumberOfGCThreads, false, \
1558 "Dynamically choose the number of parallel threads " \
1559 "parallel gc will use") \
1560 \
1561 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1562 "Force dynamic selection of the number of " \
1563 "parallel threads parallel gc will use to aid debugging") \
1564 \
1565 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1566 "Size of heap (bytes) per GC thread used in calculating the " \
1567 "number of GC threads") \
1568 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1569 \
1570 product(uint, ConcGCThreads, 0, \
1571 "Number of threads concurrent gc will use") \
1572 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1573 \
1574 product(uintx, GCTaskTimeStampEntries, 200, \
1575 "Number of time stamp entries per gc worker thread") \
1576 range(1, max_uintx) \
1577 \
1578 product(bool, AlwaysTenure, false, \
1579 "Always tenure objects in eden (ParallelGC only)") \
1580 \
1581 product(bool, NeverTenure, false, \
1582 "Never tenure objects in eden, may tenure on overflow " \
1583 "(ParallelGC only)") \
1584 \
1585 product(bool, ScavengeBeforeFullGC, true, \
1586 "Scavenge youngest generation before each full GC.") \
1587 \
1588 product(bool, UseConcMarkSweepGC, false, \
1589 "Use Concurrent Mark-Sweep GC in the old generation") \
1600 product(bool, GCLockerInvokesConcurrent, false, \
1601 "The exit of a JNI critical section necessitating a scavenge, " \
1602 "also kicks off a background concurrent collection") \
1603 \
1604 product(uintx, GCLockerEdenExpansionPercent, 5, \
1605 "How much the GC can expand the eden by while the GC locker " \
1606 "is active (as a percentage)") \
1607 range(0, 100) \
1608 \
1609 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1610 "Number of times to retry allocations when " \
1611 "blocked by the GC locker") \
1612 range(0, max_uintx) \
1613 \
1614 product(bool, UseCMSBestFit, true, \
1615 "Use CMS best fit allocation strategy") \
1616 \
1617 product(bool, UseParNewGC, false, \
1618 "Use parallel threads in the new generation") \
1619 \
1620 product(uintx, ParallelGCBufferWastePct, 10, \
1621 "Wasted fraction of parallel allocation buffer") \
1622 range(0, 100) \
1623 \
1624 product(uintx, TargetPLABWastePct, 10, \
1625 "Target wasted space in last buffer as percent of overall " \
1626 "allocation") \
1627 range(1, 100) \
1628 \
1629 product(uintx, PLABWeight, 75, \
1630 "Percentage (0-100) used to weight the current sample when " \
1631 "computing exponentially decaying average for ResizePLAB") \
1632 range(0, 100) \
1633 \
1634 product(bool, ResizePLAB, true, \
1635 "Dynamically resize (survivor space) promotion LAB's") \
1636 \
1637 product(intx, ParGCArrayScanChunk, 50, \
1638 "Scan a subset of object array and push remainder, if array is " \
1639 "bigger than this") \
1640 range(1, max_intx) \
1641 \
1642 product(bool, ParGCUseLocalOverflow, false, \
1643 "Instead of a global overflow list, use local overflow stacks") \
1644 \
1645 product(bool, ParGCTrimOverflow, true, \
1646 "Eagerly trim the local overflow lists " \
1647 "(when ParGCUseLocalOverflow)") \
1648 \
1649 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1650 "Simulate work queue overflow in ParNew") \
1651 \
1652 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1653 "An `interval' counter that determines how frequently " \
1654 "we simulate overflow; a smaller number increases frequency") \
1655 \
1656 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1660 diagnostic(uintx, ParGCStridesPerThread, 2, \
1661 "The number of strides per worker thread that we divide up the " \
1662 "card table scanning work into") \
1663 range(1, max_uintx) \
1664 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1665 \
1666 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1667 "The number of cards in each chunk of the parallel chunks used " \
1668 "during card table scanning") \
1669 range(1, max_intx) \
1670 \
1671 product(uintx, OldPLABWeight, 50, \
1672 "Percentage (0-100) used to weight the current sample when " \
1673 "computing exponentially decaying average for resizing " \
1674 "OldPLABSize") \
1675 range(0, 100) \
1676 \
1677 product(bool, ResizeOldPLAB, true, \
1678 "Dynamically resize (old gen) promotion LAB's") \
1679 \
1680 product(size_t, CMSOldPLABMax, 1024, \
1681 "Maximum size of CMS gen promotion LAB caches per worker " \
1682 "per block size") \
1683 range(1, max_uintx) \
1684 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1685 \
1686 product(size_t, CMSOldPLABMin, 16, \
1687 "Minimum size of CMS gen promotion LAB caches per worker " \
1688 "per block size") \
1689 range(1, max_uintx) \
1690 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1691 \
1692 product(uintx, CMSOldPLABNumRefills, 4, \
1693 "Nominal number of refills of CMS gen promotion LAB cache " \
1694 "per worker per block size") \
1695 range(1, max_uintx) \
1696 \
1697 product(bool, CMSOldPLABResizeQuicker, false, \
1698 "React on-the-fly during a scavenge to a sudden " \
1699 "change in block demand rate") \
1858 "Whether abort-on-overflow semantics is implemented") \
1859 \
1860 product(bool, CMSParallelInitialMarkEnabled, true, \
1861 "Use the parallel initial mark.") \
1862 \
1863 product(bool, CMSParallelRemarkEnabled, true, \
1864 "Whether parallel remark enabled (only if ParNewGC)") \
1865 \
1866 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1867 "Whether parallel remark of survivor space " \
1868 "enabled (effective only if CMSParallelRemarkEnabled)") \
1869 \
1870 product(bool, CMSPLABRecordAlways, true, \
1871 "Always record survivor space PLAB boundaries (effective only " \
1872 "if CMSParallelSurvivorRemarkEnabled)") \
1873 \
1874 product(bool, CMSEdenChunksRecordAlways, true, \
1875 "Always record eden chunks used for the parallel initial mark " \
1876 "or remark of eden") \
1877 \
1878 product(bool, CMSConcurrentMTEnabled, true, \
1879 "Whether multi-threaded concurrent work enabled " \
1880 "(effective only if ParNewGC)") \
1881 \
1882 product(bool, CMSPrecleaningEnabled, true, \
1883 "Whether concurrent precleaning enabled") \
1884 \
1885 product(uintx, CMSPrecleanIter, 3, \
1886 "Maximum number of precleaning iteration passes") \
1887 range(0, 9) \
1888 \
1889 product(uintx, CMSPrecleanDenominator, 3, \
1890 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1891 "ratio") \
1892 range(1, max_uintx) \
1893 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1894 \
1895 product(uintx, CMSPrecleanNumerator, 2, \
1896 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1897 "ratio") \
1926 range(0, max_uintx) \
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 range(min_jint, max_jint) \
1954 \
1955 develop(uintx, CMSCheckInterval, 1000, \
1956 "Interval in milliseconds that CMS thread checks if it " \
1957 "should start a collection cycle") \
1958 \
1959 product(bool, CMSYield, true, \
1960 "Yield between steps of CMS") \
1961 \
1962 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1963 "Bitmap operations should process at most this many bits " \
1964 "between yields") \
1965 range(1, max_uintx) \
1966 \
1967 product(bool, CMSPrintChunksInDump, false, \
1968 "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
1969 "trace level include more detailed information about the" \
1970 "free chunks") \
1971 \
1972 product(bool, CMSPrintObjectsInDump, false, \
1973 "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
1974 "trace level include more detailed information about the" \
1975 "allocated objects") \
1976 \
1977 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
1978 "Verify that all references across the FLS boundary " \
1979 "are to valid objects") \
1980 \
1981 diagnostic(bool, FLSVerifyLists, false, \
1982 "Do lots of (expensive) FreeListSpace verification") \
1983 \
1984 diagnostic(bool, FLSVerifyIndexTable, false, \
1985 "Do lots of (expensive) FLS index table verification") \
1986 \
1987 develop(bool, FLSVerifyDictionary, false, \
1988 "Do lots of (expensive) FLS dictionary verification") \
1989 \
1990 develop(bool, VerifyBlockOffsetArray, false, \
1991 "Do (expensive) block offset array verification") \
1992 \
1993 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
1994 "Maintain _unallocated_block in BlockOffsetArray " \
1995 "(currently applicable only to CMS collector)") \
1996 \
1997 product(intx, RefDiscoveryPolicy, 0, \
1998 "Select type of reference discovery policy: " \
1999 "reference-based(0) or referent-based(1)") \
2000 range(ReferenceProcessor::DiscoveryPolicyMin, \
2001 ReferenceProcessor::DiscoveryPolicyMax) \
2002 \
2003 product(bool, ParallelRefProcEnabled, false, \
2004 "Enable parallel reference processing whenever possible") \
2005 \
2006 product(bool, ParallelRefProcBalancingEnabled, true, \
2007 "Enable balancing of reference processing queues") \
2008 \
2009 product(uintx, CMSTriggerRatio, 80, \
2010 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2011 "allocated before a CMS collection cycle commences") \
2012 range(0, 100) \
2013 \
2014 product(uintx, CMSBootstrapOccupancy, 50, \
2015 "Percentage CMS generation occupancy at which to " \
2016 "initiate CMS collection for bootstrapping collection stats") \
2044 \
2045 develop(bool, CMSTestInFreeList, false, \
2046 "Check if the coalesced range is already in the " \
2047 "free lists as claimed") \
2048 \
2049 notproduct(bool, CMSVerifyReturnedBytes, false, \
2050 "Check that all the garbage collected was returned to the " \
2051 "free lists") \
2052 \
2053 notproduct(bool, ScavengeALot, false, \
2054 "Force scavenge at every Nth exit from the runtime system " \
2055 "(N=ScavengeALotInterval)") \
2056 \
2057 develop(bool, FullGCALot, false, \
2058 "Force full gc at every Nth exit from the runtime system " \
2059 "(N=FullGCALotInterval)") \
2060 \
2061 notproduct(bool, GCALotAtAllSafepoints, false, \
2062 "Enforce ScavengeALot/GCALot at all potential safepoints") \
2063 \
2064 notproduct(bool, PromotionFailureALot, false, \
2065 "Use promotion failure handling on every youngest generation " \
2066 "collection") \
2067 \
2068 develop(uintx, PromotionFailureALotCount, 1000, \
2069 "Number of promotion failures occurring at PLAB " \
2070 "refill attempts (ParNew) or promotion attempts " \
2071 "(other young collectors)") \
2072 \
2073 develop(uintx, PromotionFailureALotInterval, 5, \
2074 "Total collections between promotion failures a lot") \
2075 \
2076 experimental(uintx, WorkStealingSleepMillis, 1, \
2077 "Sleep time when sleep is used for yields") \
2078 \
2079 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
2080 "Number of yields before a sleep is done during work stealing") \
2081 \
2082 experimental(uintx, WorkStealingHardSpins, 4096, \
2083 "Number of iterations in a spin loop between checks on " \
2084 "time out of hard spin") \
2085 \
2086 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
2087 "Ratio of hard spins to calls to yield") \
2088 \
2089 develop(uintx, ObjArrayMarkingStride, 512, \
2090 "Number of object array elements to push onto the marking stack " \
2091 "before pushing a continuation entry") \
2092 \
2093 develop(bool, MetadataAllocationFailALot, false, \
2094 "Fail metadata allocations at intervals controlled by " \
2095 "MetadataAllocationFailALotInterval") \
2096 \
2097 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
2098 "Metadata allocation failure a lot interval") \
2099 \
2100 develop(bool, TraceMetadataChunkAllocation, false, \
2101 "Trace chunk metadata allocations") \
2102 \
2103 notproduct(bool, ExecuteInternalVMTests, false, \
2104 "Enable execution of internal VM tests") \
2105 \
2106 notproduct(bool, VerboseInternalVMTests, false, \
2107 "Turn on logging for internal VM tests.") \
2108 \
2109 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
2110 \
2111 product_pd(bool, ResizeTLAB, \
2112 "Dynamically resize TLAB size for threads") \
2113 \
2114 product(bool, ZeroTLAB, false, \
2115 "Zero out the newly created TLAB") \
2116 \
2117 product(bool, FastTLABRefill, true, \
2118 "Use fast TLAB refill code") \
2119 \
2120 product(bool, TLABStats, true, \
2121 "Provide more detailed and expensive TLAB statistics.") \
2122 \
2123 product_pd(bool, NeverActAsServerClassMachine, \
2124 "Never act like a server-class machine") \
2125 \
2126 product(bool, AlwaysActAsServerClassMachine, false, \
2127 "Always act like a server-class machine") \
2128 \
2129 product_pd(uint64_t, MaxRAM, \
2130 "Real memory size (in bytes) used to set maximum heap size") \
2131 range(0, 0XFFFFFFFFFFFFFFFF) \
2132 \
2133 product(size_t, ErgoHeapSizeLimit, 0, \
2134 "Maximum ergonomically set heap size (in bytes); zero means use " \
2135 "MaxRAM / MaxRAMFraction") \
2136 range(0, max_uintx) \
2137 \
2138 product(uintx, MaxRAMFraction, 4, \
2139 "Maximum fraction (1/n) of real memory used for maximum heap " \
2140 "size") \
2141 range(1, max_uintx) \
2161 range(0, max_uintx) \
2162 \
2163 product(bool, UseAdaptiveSizePolicy, true, \
2164 "Use adaptive generation sizing policies") \
2165 \
2166 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2167 "Use adaptive survivor sizing policies") \
2168 \
2169 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2170 "Use adaptive young-old sizing policies at minor collections") \
2171 \
2172 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2173 "Use adaptive young-old sizing policies at major collections") \
2174 \
2175 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2176 "Include statistics from System.gc() for adaptive size policy") \
2177 \
2178 product(bool, UseAdaptiveGCBoundary, false, \
2179 "Allow young-old boundary to move") \
2180 \
2181 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2182 "Resize the virtual spaces of the young or old generations") \
2183 range(-1, 1) \
2184 \
2185 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2186 "Policy for changing generation size for throughput goals") \
2187 range(0, 1) \
2188 \
2189 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2190 "Number of steps where heuristics is used before data is used") \
2191 range(0, max_uintx) \
2192 \
2193 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2194 "Number of collections before the adaptive sizing is started") \
2195 \
2196 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2197 "Collection interval for printing information; zero means never") \
2198 range(0, max_uintx) \
2199 \
2200 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2296 range(0, max_uintx) \
2297 \
2298 product(bool, UseGCOverheadLimit, true, \
2299 "Use policy to limit of proportion of time spent in GC " \
2300 "before an OutOfMemory error is thrown") \
2301 \
2302 product(uintx, GCTimeLimit, 98, \
2303 "Limit of the proportion of time spent in GC before " \
2304 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2305 range(0, 100) \
2306 \
2307 product(uintx, GCHeapFreeLimit, 2, \
2308 "Minimum percentage of free space after a full GC before an " \
2309 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2310 range(0, 100) \
2311 \
2312 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2313 "Number of consecutive collections before gc time limit fires") \
2314 range(1, max_uintx) \
2315 \
2316 product(intx, PrefetchCopyIntervalInBytes, -1, \
2317 "How far ahead to prefetch destination area (<= 0 means off)") \
2318 range(-1, max_jint) \
2319 \
2320 product(intx, PrefetchScanIntervalInBytes, -1, \
2321 "How far ahead to prefetch scan area (<= 0 means off)") \
2322 range(-1, max_jint) \
2323 \
2324 product(intx, PrefetchFieldsAhead, -1, \
2325 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2326 range(-1, max_jint) \
2327 \
2328 diagnostic(bool, VerifyDuringStartup, false, \
2329 "Verify memory system before executing any Java code " \
2330 "during VM initialization") \
2331 \
2332 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2333 "Verify system before exiting") \
2334 \
2335 diagnostic(bool, VerifyBeforeGC, false, \
2336 "Verify memory system before GC") \
2337 \
2338 diagnostic(bool, VerifyAfterGC, false, \
2339 "Verify memory system after GC") \
2340 \
2341 diagnostic(bool, VerifyDuringGC, false, \
2342 "Verify memory system during GC (between phases)") \
2343 \
2344 diagnostic(bool, GCParallelVerificationEnabled, true, \
2345 "Enable parallel memory system verification") \
2346 \
2347 diagnostic(bool, DeferInitialCardMark, false, \
2373 product(bool, BindGCTaskThreadsToCPUs, false, \
2374 "Bind GCTaskThreads to CPUs if possible") \
2375 \
2376 product(bool, UseGCTaskAffinity, false, \
2377 "Use worker affinity when asking for GCTasks") \
2378 \
2379 product(uintx, ProcessDistributionStride, 4, \
2380 "Stride through processors when distributing processes") \
2381 range(0, max_juint) \
2382 \
2383 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2384 "Number of times the coordinator GC thread will sleep while " \
2385 "yielding before giving up and resuming GC") \
2386 range(0, max_juint) \
2387 \
2388 product(uintx, CMSYieldSleepCount, 0, \
2389 "Number of times a GC thread (minus the coordinator) " \
2390 "will sleep while yielding before giving up and resuming GC") \
2391 range(0, max_juint) \
2392 \
2393 develop(intx, ConcGCYieldTimeout, 0, \
2394 "If non-zero, assert that GC threads yield within this " \
2395 "number of milliseconds") \
2396 range(0, max_intx) \
2397 \
2398 develop(bool, TraceFinalizerRegistration, false, \
2399 "Trace registration of final references") \
2400 \
2401 notproduct(bool, TraceScavenge, false, \
2402 "Trace scavenge") \
2403 \
2404 product(bool, IgnoreEmptyClassPaths, false, \
2405 "Ignore empty path elements in -classpath") \
2406 \
2407 product(bool, TraceClassPaths, false, \
2408 "Trace processing of class paths") \
2409 \
2410 product_rw(bool, TraceClassLoading, false, \
2411 "Trace all classes loaded") \
2412 \
2413 product(bool, TraceClassLoadingPreorder, false, \
2414 "Trace all classes loaded in order referenced (not loaded)") \
2415 \
2416 product_rw(bool, TraceClassUnloading, false, \
2417 "Trace unloading of classes") \
2418 \
2419 product_rw(bool, TraceLoaderConstraints, false, \
2420 "Trace loader constraints") \
2421 \
2422 develop(bool, TraceClassLoaderData, false, \
2423 "Trace class loader loader_data lifetime") \
2424 \
2425 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2426 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2427 "Initial size of the boot class loader data metaspace") \
2428 range(30*K, max_uintx/BytesPerWord) \
2429 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2430 \
2431 product(bool, TraceYoungGenTime, false, \
2432 "Trace accumulated time for young collection") \
2433 \
2434 product(bool, TraceOldGenTime, false, \
2435 "Trace accumulated time for old collection") \
2436 \
2437 product(bool, PrintHeapAtSIGBREAK, true, \
2438 "Print heap layout in response to SIGBREAK") \
2439 \
2440 manageable(bool, PrintClassHistogram, false, \
2441 "Print a histogram of class instances") \
2442 \
2443 develop(bool, TraceWorkGang, false, \
2444 "Trace activities of work gangs") \
2445 \
2446 develop(bool, TraceGCTaskManager, false, \
2447 "Trace actions of the GC task manager") \
2448 \
2449 develop(bool, TraceGCTaskQueue, false, \
2450 "Trace actions of the GC task queues") \
2451 \
2452 diagnostic(bool, TraceGCTaskThread, false, \
2453 "Trace actions of the GC task threads") \
2454 \
2455 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2456 "Trace marking phase in ParallelOldGC") \
2457 \
2458 develop(bool, TraceParallelOldGCDensePrefix, false, \
2459 "Trace dense prefix computation for ParallelOldGC") \
2460 \
2461 develop(bool, IgnoreLibthreadGPFault, false, \
2462 "Suppress workaround for libthread GP fault") \
2463 \
2464 experimental(double, ObjectCountCutOffPercent, 0.5, \
2465 "The percentage of the used heap that the instances of a class " \
2466 "must occupy for the class to generate a trace event") \
2467 range(0.0, 100.0) \
2468 \
2469 /* JVMTI heap profiling */ \
2470 \
2471 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2472 "Trace JVMTI object tagging calls") \
2473 \
2474 diagnostic(bool, VerifyBeforeIteration, false, \
2475 "Verify memory system before JVMTI iteration") \
2476 \
2477 /* compiler interface */ \
2478 \
2479 develop(bool, CIPrintCompilerName, false, \
2480 "when CIPrint is active, print the name of the active compiler") \
2481 \
2482 diagnostic(bool, CIPrintCompileQueue, false, \
2483 "display the contents of the compile queue whenever a " \
2484 "compilation is enqueued") \
2485 \
2486 develop(bool, CIPrintRequests, false, \
2487 "display every request for compilation") \
2488 \
3385 product(uintx, TargetSurvivorRatio, 50, \
3386 "Desired percentage of survivor space used after scavenge") \
3387 range(0, 100) \
3388 \
3389 product(uintx, MarkSweepDeadRatio, 5, \
3390 "Percentage (0-100) of the old gen allowed as dead wood. " \
3391 "Serial mark sweep treats this as both the minimum and maximum " \
3392 "value. " \
3393 "CMS uses this value only if it falls back to mark sweep. " \
3394 "Par compact uses a variable scale based on the density of the " \
3395 "generation and treats this as the maximum value when the heap " \
3396 "is either completely full or completely empty. Par compact " \
3397 "also has a smaller default value; see arguments.cpp.") \
3398 range(0, 100) \
3399 \
3400 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3401 "How often should we fully compact the heap (ignoring the dead " \
3402 "space parameters)") \
3403 range(1, max_uintx) \
3404 \
3405 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3406 "Delay between expansion and allocation (in milliseconds)") \
3407 \
3408 develop(uintx, GCWorkerDelayMillis, 0, \
3409 "Delay in scheduling GC workers (in milliseconds)") \
3410 \
3411 product(intx, DeferThrSuspendLoopCount, 4000, \
3412 "(Unstable) Number of times to iterate in safepoint loop " \
3413 "before blocking VM threads ") \
3414 range(-1, max_jint-1) \
3415 \
3416 product(intx, DeferPollingPageLoopCount, -1, \
3417 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3418 "before changing safepoint polling page to RO ") \
3419 range(-1, max_jint-1) \
3420 \
3421 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3422 range(0, max_intx) \
3423 \
3424 product(bool, PSChunkLargeArrays, true, \
4079 product(bool, DTraceAllocProbes, false, \
4080 "Enable dtrace probes for object allocation") \
4081 \
4082 product(bool, DTraceMonitorProbes, false, \
4083 "Enable dtrace probes for monitor events") \
4084 \
4085 product(bool, RelaxAccessControlCheck, false, \
4086 "Relax the access control checks in the verifier") \
4087 \
4088 product(uintx, StringTableSize, defaultStringTableSize, \
4089 "Number of buckets in the interned String table") \
4090 range(minimumStringTableSize, 111*defaultStringTableSize) \
4091 \
4092 experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
4093 "Number of buckets in the JVM internal Symbol table") \
4094 range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \
4095 \
4096 product(bool, UseStringDeduplication, false, \
4097 "Use string deduplication") \
4098 \
4099 product(uintx, StringDeduplicationAgeThreshold, 3, \
4100 "A string must reach this age (or be promoted to an old region) " \
4101 "to be considered for deduplication") \
4102 range(1, markOopDesc::max_age) \
4103 \
4104 diagnostic(bool, StringDeduplicationResizeALot, false, \
4105 "Force table resize every time the table is scanned") \
4106 \
4107 diagnostic(bool, StringDeduplicationRehashALot, false, \
4108 "Force table rehash every time the table is scanned") \
4109 \
4110 diagnostic(bool, WhiteBoxAPI, false, \
4111 "Enable internal testing APIs") \
4112 \
4113 experimental(intx, SurvivorAlignmentInBytes, 0, \
4114 "Default survivor space alignment in bytes") \
4115 constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \
4116 \
4117 product(bool , AllowNonVirtualCalls, false, \
4118 "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
4119 \
4120 product(ccstr, DumpLoadedClassList, NULL, \
4121 "Dump the names all loaded classes, that could be stored into " \
4122 "the CDS archive, in the specified file") \
4123 \
4124 product(ccstr, SharedClassListFile, NULL, \
4125 "Override the default CDS class list") \
4126 \
4127 diagnostic(ccstr, SharedArchiveFile, NULL, \
4128 "Override the default location of the CDS archive file") \
4129 \
4130 product(ccstr, ExtraSharedClassListFile, NULL, \
4131 "Extra classlist for building the CDS archive file") \
|