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)") \
1565 "Number of parallel threads parallel gc will use") \
1566 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1567 \
1568 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1569 "Use semaphore synchronization for the GC Threads, " \
1570 "instead of synchronization based on mutexes") \
1571 \
1572 product(bool, UseDynamicNumberOfGCThreads, false, \
1573 "Dynamically choose the number of parallel threads " \
1574 "parallel gc will use") \
1575 \
1576 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1577 "Force dynamic selection of the number of " \
1578 "parallel threads parallel gc will use to aid debugging") \
1579 \
1580 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1581 "Size of heap (bytes) per GC thread used in calculating the " \
1582 "number of GC threads") \
1583 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1584 \
1585 product(bool, TraceDynamicGCThreads, false, \
1586 "Trace the dynamic GC thread usage") \
1587 \
1588 product(uint, ConcGCThreads, 0, \
1589 "Number of threads concurrent gc will use") \
1590 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1591 \
1592 product(uintx, GCTaskTimeStampEntries, 200, \
1593 "Number of time stamp entries per gc worker thread") \
1594 range(1, max_uintx) \
1595 \
1596 product(bool, AlwaysTenure, false, \
1597 "Always tenure objects in eden (ParallelGC only)") \
1598 \
1599 product(bool, NeverTenure, false, \
1600 "Never tenure objects in eden, may tenure on overflow " \
1601 "(ParallelGC only)") \
1602 \
1603 product(bool, ScavengeBeforeFullGC, true, \
1604 "Scavenge youngest generation before each full GC.") \
1605 \
1606 product(bool, UseConcMarkSweepGC, false, \
1607 "Use Concurrent Mark-Sweep GC in the old generation") \
1617 \
1618 product(bool, GCLockerInvokesConcurrent, false, \
1619 "The exit of a JNI critical section necessitating a scavenge, " \
1620 "also kicks off a background concurrent collection") \
1621 \
1622 product(uintx, GCLockerEdenExpansionPercent, 5, \
1623 "How much the GC can expand the eden by while the GC locker " \
1624 "is active (as a percentage)") \
1625 range(0, 100) \
1626 \
1627 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1628 "Number of times to retry allocations when " \
1629 "blocked by the GC locker") \
1630 \
1631 product(bool, UseCMSBestFit, true, \
1632 "Use CMS best fit allocation strategy") \
1633 \
1634 product(bool, UseParNewGC, false, \
1635 "Use parallel threads in the new generation") \
1636 \
1637 product(bool, PrintTaskqueue, false, \
1638 "Print taskqueue statistics for parallel collectors") \
1639 \
1640 product(bool, PrintTerminationStats, false, \
1641 "Print termination statistics for parallel collectors") \
1642 \
1643 product(uintx, ParallelGCBufferWastePct, 10, \
1644 "Wasted fraction of parallel allocation buffer") \
1645 range(0, 100) \
1646 \
1647 product(uintx, TargetPLABWastePct, 10, \
1648 "Target wasted space in last buffer as percent of overall " \
1649 "allocation") \
1650 range(1, 100) \
1651 \
1652 product(uintx, PLABWeight, 75, \
1653 "Percentage (0-100) used to weight the current sample when " \
1654 "computing exponentially decaying average for ResizePLAB") \
1655 range(0, 100) \
1656 \
1657 product(bool, ResizePLAB, true, \
1658 "Dynamically resize (survivor space) promotion LAB's") \
1659 \
1660 product(bool, PrintPLAB, false, \
1661 "Print (survivor space) promotion LAB's sizing decisions") \
1662 \
1663 product(intx, ParGCArrayScanChunk, 50, \
1664 "Scan a subset of object array and push remainder, if array is " \
1665 "bigger than this") \
1666 range(1, max_intx) \
1667 \
1668 product(bool, ParGCUseLocalOverflow, false, \
1669 "Instead of a global overflow list, use local overflow stacks") \
1670 \
1671 product(bool, ParGCTrimOverflow, true, \
1672 "Eagerly trim the local overflow lists " \
1673 "(when ParGCUseLocalOverflow)") \
1674 \
1675 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1676 "Simulate work queue overflow in ParNew") \
1677 \
1678 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1679 "An `interval' counter that determines how frequently " \
1680 "we simulate overflow; a smaller number increases frequency") \
1681 \
1682 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1685 diagnostic(uintx, ParGCStridesPerThread, 2, \
1686 "The number of strides per worker thread that we divide up the " \
1687 "card table scanning work into") \
1688 range(1, max_uintx) \
1689 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1690 \
1691 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1692 "The number of cards in each chunk of the parallel chunks used " \
1693 "during card table scanning") \
1694 range(1, max_intx) \
1695 \
1696 product(uintx, OldPLABWeight, 50, \
1697 "Percentage (0-100) used to weight the current sample when " \
1698 "computing exponentially decaying average for resizing " \
1699 "OldPLABSize") \
1700 range(0, 100) \
1701 \
1702 product(bool, ResizeOldPLAB, true, \
1703 "Dynamically resize (old gen) promotion LAB's") \
1704 \
1705 product(bool, PrintOldPLAB, false, \
1706 "Print (old gen) promotion LAB's sizing decisions") \
1707 \
1708 product(size_t, CMSOldPLABMax, 1024, \
1709 "Maximum size of CMS gen promotion LAB caches per worker " \
1710 "per block size") \
1711 range(1, max_uintx) \
1712 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1713 \
1714 product(size_t, CMSOldPLABMin, 16, \
1715 "Minimum size of CMS gen promotion LAB caches per worker " \
1716 "per block size") \
1717 range(1, max_uintx) \
1718 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1719 \
1720 product(uintx, CMSOldPLABNumRefills, 4, \
1721 "Nominal number of refills of CMS gen promotion LAB cache " \
1722 "per worker per block size") \
1723 range(1, max_uintx) \
1724 \
1725 product(bool, CMSOldPLABResizeQuicker, false, \
1726 "React on-the-fly during a scavenge to a sudden " \
1727 "change in block demand rate") \
1879 "Whether abort-on-overflow semantics is implemented") \
1880 \
1881 product(bool, CMSParallelInitialMarkEnabled, true, \
1882 "Use the parallel initial mark.") \
1883 \
1884 product(bool, CMSParallelRemarkEnabled, true, \
1885 "Whether parallel remark enabled (only if ParNewGC)") \
1886 \
1887 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1888 "Whether parallel remark of survivor space " \
1889 "enabled (effective only if CMSParallelRemarkEnabled)") \
1890 \
1891 product(bool, CMSPLABRecordAlways, true, \
1892 "Always record survivor space PLAB boundaries (effective only " \
1893 "if CMSParallelSurvivorRemarkEnabled)") \
1894 \
1895 product(bool, CMSEdenChunksRecordAlways, true, \
1896 "Always record eden chunks used for the parallel initial mark " \
1897 "or remark of eden") \
1898 \
1899 product(bool, CMSPrintEdenSurvivorChunks, false, \
1900 "Print the eden and the survivor chunks used for the parallel " \
1901 "initial mark or remark of the eden/survivor spaces") \
1902 \
1903 product(bool, CMSConcurrentMTEnabled, true, \
1904 "Whether multi-threaded concurrent work enabled " \
1905 "(effective only if ParNewGC)") \
1906 \
1907 product(bool, CMSPrecleaningEnabled, true, \
1908 "Whether concurrent precleaning enabled") \
1909 \
1910 product(uintx, CMSPrecleanIter, 3, \
1911 "Maximum number of precleaning iteration passes") \
1912 range(0, 9) \
1913 \
1914 product(uintx, CMSPrecleanDenominator, 3, \
1915 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1916 "ratio") \
1917 range(1, max_uintx) \
1918 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1919 \
1920 product(uintx, CMSPrecleanNumerator, 2, \
1921 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1922 "ratio") \
1950 "If Eden size is below this, do not try to schedule remark") \
1951 \
1952 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1953 "The Eden occupancy percentage (0-100) at which " \
1954 "to try and schedule remark pause") \
1955 range(0, 100) \
1956 \
1957 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1958 "Start sampling eden top at least before young gen " \
1959 "occupancy reaches 1/<ratio> of the size at which " \
1960 "we plan to schedule remark") \
1961 range(1, max_uintx) \
1962 \
1963 product(uintx, CMSSamplingGrain, 16*K, \
1964 "The minimum distance between eden samples for CMS (see above)") \
1965 range(1, max_uintx) \
1966 \
1967 product(bool, CMSScavengeBeforeRemark, false, \
1968 "Attempt scavenge before the CMS remark step") \
1969 \
1970 develop(bool, CMSTraceSweeper, false, \
1971 "Trace some actions of the CMS sweeper") \
1972 \
1973 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1974 "Don't drain below this size per parallel worker/thief") \
1975 range(1, max_juint) \
1976 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1977 \
1978 manageable(intx, CMSWaitDuration, 2000, \
1979 "Time in milliseconds that CMS thread waits for young GC") \
1980 \
1981 develop(uintx, CMSCheckInterval, 1000, \
1982 "Interval in milliseconds that CMS thread checks if it " \
1983 "should start a collection cycle") \
1984 \
1985 product(bool, CMSYield, true, \
1986 "Yield between steps of CMS") \
1987 \
1988 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1989 "Bitmap operations should process at most this many bits " \
1990 "between yields") \
1991 range(1, max_uintx) \
1992 \
1993 product(bool, CMSDumpAtPromotionFailure, false, \
1994 "Dump useful information about the state of the CMS old " \
1995 "generation upon a promotion failure") \
1996 \
1997 product(bool, CMSPrintChunksInDump, false, \
1998 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1999 "more detailed information about the free chunks") \
2000 \
2001 product(bool, CMSPrintObjectsInDump, false, \
2002 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
2003 "more detailed information about the allocated objects") \
2004 \
2005 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
2006 "Verify that all references across the FLS boundary " \
2007 "are to valid objects") \
2008 \
2009 diagnostic(bool, FLSVerifyLists, false, \
2010 "Do lots of (expensive) FreeListSpace verification") \
2011 \
2012 diagnostic(bool, FLSVerifyIndexTable, false, \
2013 "Do lots of (expensive) FLS index table verification") \
2014 \
2015 develop(bool, FLSVerifyDictionary, false, \
2016 "Do lots of (expensive) FLS dictionary verification") \
2017 \
2018 develop(bool, VerifyBlockOffsetArray, false, \
2019 "Do (expensive) block offset array verification") \
2020 \
2021 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
2022 "Maintain _unallocated_block in BlockOffsetArray " \
2023 "(currently applicable only to CMS collector)") \
2024 \
2025 develop(bool, TraceCMSState, false, \
2026 "Trace the state of the CMS collection") \
2027 \
2028 product(intx, RefDiscoveryPolicy, 0, \
2029 "Select type of reference discovery policy: " \
2030 "reference-based(0) or referent-based(1)") \
2031 range(ReferenceProcessor::DiscoveryPolicyMin, \
2032 ReferenceProcessor::DiscoveryPolicyMax) \
2033 \
2034 product(bool, ParallelRefProcEnabled, false, \
2035 "Enable parallel reference processing whenever possible") \
2036 \
2037 product(bool, ParallelRefProcBalancingEnabled, true, \
2038 "Enable balancing of reference processing queues") \
2039 \
2040 product(uintx, CMSTriggerRatio, 80, \
2041 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2042 "allocated before a CMS collection cycle commences") \
2043 range(0, 100) \
2044 \
2045 product(uintx, CMSBootstrapOccupancy, 50, \
2046 "Percentage CMS generation occupancy at which to " \
2047 "initiate CMS collection for bootstrapping collection stats") \
2075 \
2076 develop(bool, CMSTestInFreeList, false, \
2077 "Check if the coalesced range is already in the " \
2078 "free lists as claimed") \
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, \
2407 diagnostic(uintx, CPUForCMSThread, 0, \
2408 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2409 \
2410 product(bool, BindGCTaskThreadsToCPUs, false, \
2411 "Bind GCTaskThreads to CPUs if possible") \
2412 \
2413 product(bool, UseGCTaskAffinity, 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 develop(bool, TraceBlockOffsetTable, false, \
2523 "Print BlockOffsetTable maps") \
2524 \
2525 develop(bool, TraceCardTableModRefBS, false, \
2526 "Print CardTableModRefBS maps") \
2527 \
2528 develop(bool, TraceGCTaskManager, false, \
2529 "Trace actions of the GC task manager") \
2530 \
2531 develop(bool, TraceGCTaskQueue, false, \
2532 "Trace actions of the GC task queues") \
2533 \
2534 diagnostic(bool, TraceGCTaskThread, false, \
2535 "Trace actions of the GC task threads") \
2536 \
2537 product(bool, PrintParallelOldGCPhaseTimes, false, \
2538 "Print the time taken by each phase in ParallelOldGC " \
2539 "(PrintGCDetails must also be enabled)") \
2540 \
2541 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2542 "Trace marking phase in ParallelOldGC") \
2543 \
2544 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2545 "Trace summary phase in ParallelOldGC") \
2546 \
2547 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2548 "Trace compaction phase in ParallelOldGC") \
2549 \
2550 develop(bool, TraceParallelOldGCDensePrefix, false, \
2551 "Trace dense prefix computation for ParallelOldGC") \
2552 \
2553 develop(bool, IgnoreLibthreadGPFault, false, \
2554 "Suppress workaround for libthread GP fault") \
2555 \
2556 product(bool, PrintJNIGCStalls, false, \
2557 "Print diagnostic message when GC is stalled " \
2558 "by JNI critical section") \
2559 \
2560 experimental(double, ObjectCountCutOffPercent, 0.5, \
2561 "The percentage of the used heap that the instances of a class " \
2562 "must occupy for the class to generate a trace event") \
2563 range(0.0, 100.0) \
2564 \
2565 /* GC log rotation setting */ \
2566 \
2567 product(bool, UseGCLogFileRotation, false, \
2568 "Rotate gclog files (for long running applications). It requires "\
2569 "-Xloggc:<filename>") \
2570 \
2571 product(uintx, NumberOfGCLogFiles, 0, \
2572 "Number of gclog files in rotation " \
2573 "(default: 0, no rotation)") \
2574 \
2575 product(size_t, GCLogFileSize, 8*K, \
2576 "GC log file size, requires UseGCLogFileRotation. " \
2577 "Set to 0 to only trigger rotation via jcmd") \
2578 \
2579 /* JVMTI heap profiling */ \
2580 \
2581 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2582 "Trace JVMTI object tagging calls") \
2583 \
2584 diagnostic(bool, VerifyBeforeIteration, false, \
2585 "Verify memory system before JVMTI iteration") \
2586 \
2587 /* compiler interface */ \
2588 \
2589 develop(bool, CIPrintCompilerName, false, \
2590 "when CIPrint is active, print the name of the active compiler") \
2591 \
2592 diagnostic(bool, CIPrintCompileQueue, false, \
2593 "display the contents of the compile queue whenever a " \
2594 "compilation is enqueued") \
2595 \
2596 develop(bool, CIPrintRequests, false, \
2597 "display every request for compilation") \
2598 \
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 \
3525 product(bool, PSChunkLargeArrays, true, \
4190 \
4191 product(bool, UseStringDeduplication, false, \
4192 "Use string deduplication") \
4193 \
4194 product(bool, PrintStringDeduplicationStatistics, false, \
4195 "Print string deduplication statistics") \
4196 \
4197 product(uintx, StringDeduplicationAgeThreshold, 3, \
4198 "A string must reach this age (or be promoted to an old region) " \
4199 "to be considered for deduplication") \
4200 range(1, markOopDesc::max_age) \
4201 \
4202 diagnostic(bool, StringDeduplicationResizeALot, false, \
4203 "Force table resize every time the table is scanned") \
4204 \
4205 diagnostic(bool, StringDeduplicationRehashALot, false, \
4206 "Force table rehash every time the table is scanned") \
4207 \
4208 diagnostic(bool, WhiteBoxAPI, false, \
4209 "Enable internal testing APIs") \
4210 \
4211 product(bool, PrintGCCause, true, \
4212 "Include GC cause in GC logging") \
4213 \
4214 experimental(intx, SurvivorAlignmentInBytes, 0, \
4215 "Default survivor space alignment in bytes") \
4216 constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \
4217 \
4218 product(bool , AllowNonVirtualCalls, false, \
4219 "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
4220 \
4221 product(ccstr, DumpLoadedClassList, NULL, \
4222 "Dump the names all loaded classes, that could be stored into " \
4223 "the CDS archive, in the specified file") \
4224 \
4225 product(ccstr, SharedClassListFile, NULL, \
4226 "Override the default CDS class list") \
4227 \
4228 diagnostic(ccstr, SharedArchiveFile, NULL, \
4229 "Override the default location of the CDS archive file") \
4230 \
4231 product(ccstr, ExtraSharedClassListFile, NULL, \
4232 "Extra classlist for building the CDS archive file") \
|
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)") \
1556 "Number of parallel threads parallel gc will use") \
1557 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1558 \
1559 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1560 "Use semaphore synchronization for the GC Threads, " \
1561 "instead of synchronization based on mutexes") \
1562 \
1563 product(bool, UseDynamicNumberOfGCThreads, false, \
1564 "Dynamically choose the number of parallel threads " \
1565 "parallel gc will use") \
1566 \
1567 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1568 "Force dynamic selection of the number of " \
1569 "parallel threads parallel gc will use to aid debugging") \
1570 \
1571 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1572 "Size of heap (bytes) per GC thread used in calculating the " \
1573 "number of GC threads") \
1574 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1575 \
1576 product(uint, ConcGCThreads, 0, \
1577 "Number of threads concurrent gc will use") \
1578 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1579 \
1580 product(uintx, GCTaskTimeStampEntries, 200, \
1581 "Number of time stamp entries per gc worker thread") \
1582 range(1, max_uintx) \
1583 \
1584 product(bool, AlwaysTenure, false, \
1585 "Always tenure objects in eden (ParallelGC only)") \
1586 \
1587 product(bool, NeverTenure, false, \
1588 "Never tenure objects in eden, may tenure on overflow " \
1589 "(ParallelGC only)") \
1590 \
1591 product(bool, ScavengeBeforeFullGC, true, \
1592 "Scavenge youngest generation before each full GC.") \
1593 \
1594 product(bool, UseConcMarkSweepGC, false, \
1595 "Use Concurrent Mark-Sweep GC in the old generation") \
1605 \
1606 product(bool, GCLockerInvokesConcurrent, false, \
1607 "The exit of a JNI critical section necessitating a scavenge, " \
1608 "also kicks off a background concurrent collection") \
1609 \
1610 product(uintx, GCLockerEdenExpansionPercent, 5, \
1611 "How much the GC can expand the eden by while the GC locker " \
1612 "is active (as a percentage)") \
1613 range(0, 100) \
1614 \
1615 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1616 "Number of times to retry allocations when " \
1617 "blocked by the GC locker") \
1618 \
1619 product(bool, UseCMSBestFit, true, \
1620 "Use CMS best fit allocation strategy") \
1621 \
1622 product(bool, UseParNewGC, false, \
1623 "Use parallel threads in the new generation") \
1624 \
1625 product(uintx, ParallelGCBufferWastePct, 10, \
1626 "Wasted fraction of parallel allocation buffer") \
1627 range(0, 100) \
1628 \
1629 product(uintx, TargetPLABWastePct, 10, \
1630 "Target wasted space in last buffer as percent of overall " \
1631 "allocation") \
1632 range(1, 100) \
1633 \
1634 product(uintx, PLABWeight, 75, \
1635 "Percentage (0-100) used to weight the current sample when " \
1636 "computing exponentially decaying average for ResizePLAB") \
1637 range(0, 100) \
1638 \
1639 product(bool, ResizePLAB, true, \
1640 "Dynamically resize (survivor space) promotion LAB's") \
1641 \
1642 product(intx, ParGCArrayScanChunk, 50, \
1643 "Scan a subset of object array and push remainder, if array is " \
1644 "bigger than this") \
1645 range(1, max_intx) \
1646 \
1647 product(bool, ParGCUseLocalOverflow, false, \
1648 "Instead of a global overflow list, use local overflow stacks") \
1649 \
1650 product(bool, ParGCTrimOverflow, true, \
1651 "Eagerly trim the local overflow lists " \
1652 "(when ParGCUseLocalOverflow)") \
1653 \
1654 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1655 "Simulate work queue overflow in ParNew") \
1656 \
1657 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1658 "An `interval' counter that determines how frequently " \
1659 "we simulate overflow; a smaller number increases frequency") \
1660 \
1661 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1664 diagnostic(uintx, ParGCStridesPerThread, 2, \
1665 "The number of strides per worker thread that we divide up the " \
1666 "card table scanning work into") \
1667 range(1, max_uintx) \
1668 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1669 \
1670 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1671 "The number of cards in each chunk of the parallel chunks used " \
1672 "during card table scanning") \
1673 range(1, max_intx) \
1674 \
1675 product(uintx, OldPLABWeight, 50, \
1676 "Percentage (0-100) used to weight the current sample when " \
1677 "computing exponentially decaying average for resizing " \
1678 "OldPLABSize") \
1679 range(0, 100) \
1680 \
1681 product(bool, ResizeOldPLAB, true, \
1682 "Dynamically resize (old gen) promotion LAB's") \
1683 \
1684 product(size_t, CMSOldPLABMax, 1024, \
1685 "Maximum size of CMS gen promotion LAB caches per worker " \
1686 "per block size") \
1687 range(1, max_uintx) \
1688 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1689 \
1690 product(size_t, CMSOldPLABMin, 16, \
1691 "Minimum size of CMS gen promotion LAB caches per worker " \
1692 "per block size") \
1693 range(1, max_uintx) \
1694 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1695 \
1696 product(uintx, CMSOldPLABNumRefills, 4, \
1697 "Nominal number of refills of CMS gen promotion LAB cache " \
1698 "per worker per block size") \
1699 range(1, max_uintx) \
1700 \
1701 product(bool, CMSOldPLABResizeQuicker, false, \
1702 "React on-the-fly during a scavenge to a sudden " \
1703 "change in block demand rate") \
1855 "Whether abort-on-overflow semantics is implemented") \
1856 \
1857 product(bool, CMSParallelInitialMarkEnabled, true, \
1858 "Use the parallel initial mark.") \
1859 \
1860 product(bool, CMSParallelRemarkEnabled, true, \
1861 "Whether parallel remark enabled (only if ParNewGC)") \
1862 \
1863 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1864 "Whether parallel remark of survivor space " \
1865 "enabled (effective only if CMSParallelRemarkEnabled)") \
1866 \
1867 product(bool, CMSPLABRecordAlways, true, \
1868 "Always record survivor space PLAB boundaries (effective only " \
1869 "if CMSParallelSurvivorRemarkEnabled)") \
1870 \
1871 product(bool, CMSEdenChunksRecordAlways, true, \
1872 "Always record eden chunks used for the parallel initial mark " \
1873 "or remark of eden") \
1874 \
1875 product(bool, CMSConcurrentMTEnabled, true, \
1876 "Whether multi-threaded concurrent work enabled " \
1877 "(effective only if ParNewGC)") \
1878 \
1879 product(bool, CMSPrecleaningEnabled, true, \
1880 "Whether concurrent precleaning enabled") \
1881 \
1882 product(uintx, CMSPrecleanIter, 3, \
1883 "Maximum number of precleaning iteration passes") \
1884 range(0, 9) \
1885 \
1886 product(uintx, CMSPrecleanDenominator, 3, \
1887 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1888 "ratio") \
1889 range(1, max_uintx) \
1890 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1891 \
1892 product(uintx, CMSPrecleanNumerator, 2, \
1893 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1894 "ratio") \
1922 "If Eden size is below this, do not try to schedule remark") \
1923 \
1924 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1925 "The Eden occupancy percentage (0-100) at which " \
1926 "to try and schedule remark pause") \
1927 range(0, 100) \
1928 \
1929 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1930 "Start sampling eden top at least before young gen " \
1931 "occupancy reaches 1/<ratio> of the size at which " \
1932 "we plan to schedule remark") \
1933 range(1, max_uintx) \
1934 \
1935 product(uintx, CMSSamplingGrain, 16*K, \
1936 "The minimum distance between eden samples for CMS (see above)") \
1937 range(1, max_uintx) \
1938 \
1939 product(bool, CMSScavengeBeforeRemark, false, \
1940 "Attempt scavenge before the CMS remark step") \
1941 \
1942 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1943 "Don't drain below this size per parallel worker/thief") \
1944 range(1, max_juint) \
1945 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1946 \
1947 manageable(intx, CMSWaitDuration, 2000, \
1948 "Time in milliseconds that CMS thread waits for young GC") \
1949 \
1950 develop(uintx, CMSCheckInterval, 1000, \
1951 "Interval in milliseconds that CMS thread checks if it " \
1952 "should start a collection cycle") \
1953 \
1954 product(bool, CMSYield, true, \
1955 "Yield between steps of CMS") \
1956 \
1957 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1958 "Bitmap operations should process at most this many bits " \
1959 "between yields") \
1960 range(1, max_uintx) \
1961 \
1962 product(bool, CMSPrintChunksInDump, false, \
1963 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1964 "more detailed information about the free chunks") \
1965 \
1966 product(bool, CMSPrintObjectsInDump, false, \
1967 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1968 "more detailed information about the allocated objects") \
1969 \
1970 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
1971 "Verify that all references across the FLS boundary " \
1972 "are to valid objects") \
1973 \
1974 diagnostic(bool, FLSVerifyLists, false, \
1975 "Do lots of (expensive) FreeListSpace verification") \
1976 \
1977 diagnostic(bool, FLSVerifyIndexTable, false, \
1978 "Do lots of (expensive) FLS index table verification") \
1979 \
1980 develop(bool, FLSVerifyDictionary, false, \
1981 "Do lots of (expensive) FLS dictionary verification") \
1982 \
1983 develop(bool, VerifyBlockOffsetArray, false, \
1984 "Do (expensive) block offset array verification") \
1985 \
1986 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
1987 "Maintain _unallocated_block in BlockOffsetArray " \
1988 "(currently applicable only to CMS collector)") \
1989 \
1990 product(intx, RefDiscoveryPolicy, 0, \
1991 "Select type of reference discovery policy: " \
1992 "reference-based(0) or referent-based(1)") \
1993 range(ReferenceProcessor::DiscoveryPolicyMin, \
1994 ReferenceProcessor::DiscoveryPolicyMax) \
1995 \
1996 product(bool, ParallelRefProcEnabled, false, \
1997 "Enable parallel reference processing whenever possible") \
1998 \
1999 product(bool, ParallelRefProcBalancingEnabled, true, \
2000 "Enable balancing of reference processing queues") \
2001 \
2002 product(uintx, CMSTriggerRatio, 80, \
2003 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2004 "allocated before a CMS collection cycle commences") \
2005 range(0, 100) \
2006 \
2007 product(uintx, CMSBootstrapOccupancy, 50, \
2008 "Percentage CMS generation occupancy at which to " \
2009 "initiate CMS collection for bootstrapping collection stats") \
2037 \
2038 develop(bool, CMSTestInFreeList, false, \
2039 "Check if the coalesced range is already in the " \
2040 "free lists as claimed") \
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, \
2346 diagnostic(uintx, CPUForCMSThread, 0, \
2347 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2348 \
2349 product(bool, BindGCTaskThreadsToCPUs, false, \
2350 "Bind GCTaskThreads to CPUs if possible") \
2351 \
2352 product(bool, UseGCTaskAffinity, 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 develop(intx, ConcGCYieldTimeout, 0, \
2367 "If non-zero, assert that GC threads yield within this " \
2368 "number of milliseconds") \
2369 range(0, max_intx) \
2370 \
2371 develop(bool, TraceFinalizerRegistration, false, \
2372 "Trace registration of final references") \
2373 \
2374 notproduct(bool, TraceScavenge, false, \
2375 "Trace scavenge") \
2376 \
2377 product(bool, IgnoreEmptyClassPaths, false, \
2378 "Ignore empty path elements in -classpath") \
2379 \
2380 product(bool, TraceClassPaths, false, \
2381 "Trace processing of class paths") \
2382 \
2383 product_rw(bool, TraceClassLoading, false, \
2384 "Trace all classes loaded") \
2385 \
2386 product(bool, TraceClassLoadingPreorder, false, \
2387 "Trace all classes loaded in order referenced (not loaded)") \
2388 \
2389 product_rw(bool, TraceClassUnloading, false, \
2390 "Trace unloading of classes") \
2391 \
2392 product_rw(bool, TraceLoaderConstraints, false, \
2393 "Trace loader constraints") \
2394 \
2395 develop(bool, TraceClassLoaderData, false, \
2396 "Trace class loader loader_data lifetime") \
2397 \
2398 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2399 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2400 "Initial size of the boot class loader data metaspace") \
2401 range(30*K, max_uintx/BytesPerWord) \
2402 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2403 \
2404 product(bool, TraceYoungGenTime, false, \
2405 "Trace accumulated time for young collection") \
2406 \
2407 product(bool, TraceOldGenTime, false, \
2408 "Trace accumulated time for old collection") \
2409 \
2410 product(bool, PrintHeapAtSIGBREAK, true, \
2411 "Print heap layout in response to SIGBREAK") \
2412 \
2413 manageable(bool, PrintClassHistogramAfterFullGC, false, \
2414 "Print a class histogram after any major stop-world GC") \
2415 \
2416 manageable(bool, PrintClassHistogram, false, \
2417 "Print a histogram of class instances") \
2418 \
2419 develop(bool, TraceWorkGang, false, \
2420 "Trace activities of work gangs") \
2421 \
2422 develop(bool, TraceGCTaskManager, false, \
2423 "Trace actions of the GC task manager") \
2424 \
2425 develop(bool, TraceGCTaskQueue, false, \
2426 "Trace actions of the GC task queues") \
2427 \
2428 diagnostic(bool, TraceGCTaskThread, false, \
2429 "Trace actions of the GC task threads") \
2430 \
2431 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2432 "Trace marking phase in ParallelOldGC") \
2433 \
2434 develop(bool, TraceParallelOldGCDensePrefix, false, \
2435 "Trace dense prefix computation for ParallelOldGC") \
2436 \
2437 develop(bool, IgnoreLibthreadGPFault, false, \
2438 "Suppress workaround for libthread GP fault") \
2439 \
2440 product(bool, PrintJNIGCStalls, false, \
2441 "Print diagnostic message when GC is stalled " \
2442 "by JNI critical section") \
2443 \
2444 experimental(double, ObjectCountCutOffPercent, 0.5, \
2445 "The percentage of the used heap that the instances of a class " \
2446 "must occupy for the class to generate a trace event") \
2447 range(0.0, 100.0) \
2448 \
2449 /* JVMTI heap profiling */ \
2450 \
2451 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2452 "Trace JVMTI object tagging calls") \
2453 \
2454 diagnostic(bool, VerifyBeforeIteration, false, \
2455 "Verify memory system before JVMTI iteration") \
2456 \
2457 /* compiler interface */ \
2458 \
2459 develop(bool, CIPrintCompilerName, false, \
2460 "when CIPrint is active, print the name of the active compiler") \
2461 \
2462 diagnostic(bool, CIPrintCompileQueue, false, \
2463 "display the contents of the compile queue whenever a " \
2464 "compilation is enqueued") \
2465 \
2466 develop(bool, CIPrintRequests, false, \
2467 "display every request for compilation") \
2468 \
3344 product(uintx, TargetSurvivorRatio, 50, \
3345 "Desired percentage of survivor space used after scavenge") \
3346 range(0, 100) \
3347 \
3348 product(uintx, MarkSweepDeadRatio, 5, \
3349 "Percentage (0-100) of the old gen allowed as dead wood. " \
3350 "Serial mark sweep treats this as both the minimum and maximum " \
3351 "value. " \
3352 "CMS uses this value only if it falls back to mark sweep. " \
3353 "Par compact uses a variable scale based on the density of the " \
3354 "generation and treats this as the maximum value when the heap " \
3355 "is either completely full or completely empty. Par compact " \
3356 "also has a smaller default value; see arguments.cpp.") \
3357 range(0, 100) \
3358 \
3359 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3360 "How often should we fully compact the heap (ignoring the dead " \
3361 "space parameters)") \
3362 range(1, max_uintx) \
3363 \
3364 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3365 "Delay between expansion and allocation (in milliseconds)") \
3366 \
3367 develop(uintx, GCWorkerDelayMillis, 0, \
3368 "Delay in scheduling GC workers (in milliseconds)") \
3369 \
3370 product(intx, DeferThrSuspendLoopCount, 4000, \
3371 "(Unstable) Number of times to iterate in safepoint loop " \
3372 "before blocking VM threads ") \
3373 range(-1, max_jint-1) \
3374 \
3375 product(intx, DeferPollingPageLoopCount, -1, \
3376 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3377 "before changing safepoint polling page to RO ") \
3378 range(-1, max_jint-1) \
3379 \
3380 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3381 range(0, max_intx) \
3382 \
3383 product(bool, PSChunkLargeArrays, true, \
4048 \
4049 product(bool, UseStringDeduplication, false, \
4050 "Use string deduplication") \
4051 \
4052 product(bool, PrintStringDeduplicationStatistics, false, \
4053 "Print string deduplication statistics") \
4054 \
4055 product(uintx, StringDeduplicationAgeThreshold, 3, \
4056 "A string must reach this age (or be promoted to an old region) " \
4057 "to be considered for deduplication") \
4058 range(1, markOopDesc::max_age) \
4059 \
4060 diagnostic(bool, StringDeduplicationResizeALot, false, \
4061 "Force table resize every time the table is scanned") \
4062 \
4063 diagnostic(bool, StringDeduplicationRehashALot, false, \
4064 "Force table rehash every time the table is scanned") \
4065 \
4066 diagnostic(bool, WhiteBoxAPI, false, \
4067 "Enable internal testing APIs") \
4068 \
4069 experimental(intx, SurvivorAlignmentInBytes, 0, \
4070 "Default survivor space alignment in bytes") \
4071 constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \
4072 \
4073 product(bool , AllowNonVirtualCalls, false, \
4074 "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
4075 \
4076 product(ccstr, DumpLoadedClassList, NULL, \
4077 "Dump the names all loaded classes, that could be stored into " \
4078 "the CDS archive, in the specified file") \
4079 \
4080 product(ccstr, SharedClassListFile, NULL, \
4081 "Override the default CDS class list") \
4082 \
4083 diagnostic(ccstr, SharedArchiveFile, NULL, \
4084 "Override the default location of the CDS archive file") \
4085 \
4086 product(ccstr, ExtraSharedClassListFile, NULL, \
4087 "Extra classlist for building the CDS archive file") \
|