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)") \
1554 "Number of parallel threads parallel gc will use") \
1555 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1556 \
1557 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1558 "Use semaphore synchronization for the GC Threads, " \
1559 "instead of synchronization based on mutexes") \
1560 \
1561 product(bool, UseDynamicNumberOfGCThreads, false, \
1562 "Dynamically choose the number of parallel threads " \
1563 "parallel gc will use") \
1564 \
1565 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1566 "Force dynamic selection of the number of " \
1567 "parallel threads parallel gc will use to aid debugging") \
1568 \
1569 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1570 "Size of heap (bytes) per GC thread used in calculating the " \
1571 "number of GC threads") \
1572 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1573 \
1574 product(bool, TraceDynamicGCThreads, false, \
1575 "Trace the dynamic GC thread usage") \
1576 \
1577 product(uint, ConcGCThreads, 0, \
1578 "Number of threads concurrent gc will use") \
1579 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1580 \
1581 product(uintx, GCTaskTimeStampEntries, 200, \
1582 "Number of time stamp entries per gc worker thread") \
1583 range(1, max_uintx) \
1584 \
1585 product(bool, AlwaysTenure, false, \
1586 "Always tenure objects in eden (ParallelGC only)") \
1587 \
1588 product(bool, NeverTenure, false, \
1589 "Never tenure objects in eden, may tenure on overflow " \
1590 "(ParallelGC only)") \
1591 \
1592 product(bool, ScavengeBeforeFullGC, true, \
1593 "Scavenge youngest generation before each full GC.") \
1594 \
1595 product(bool, UseConcMarkSweepGC, false, \
1596 "Use Concurrent Mark-Sweep GC in the old generation") \
1606 \
1607 product(bool, GCLockerInvokesConcurrent, false, \
1608 "The exit of a JNI critical section necessitating a scavenge, " \
1609 "also kicks off a background concurrent collection") \
1610 \
1611 product(uintx, GCLockerEdenExpansionPercent, 5, \
1612 "How much the GC can expand the eden by while the GC locker " \
1613 "is active (as a percentage)") \
1614 range(0, 100) \
1615 \
1616 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1617 "Number of times to retry allocations when " \
1618 "blocked by the GC locker") \
1619 \
1620 product(bool, UseCMSBestFit, true, \
1621 "Use CMS best fit allocation strategy") \
1622 \
1623 product(bool, UseParNewGC, false, \
1624 "Use parallel threads in the new generation") \
1625 \
1626 product(bool, PrintTaskqueue, false, \
1627 "Print taskqueue statistics for parallel collectors") \
1628 \
1629 product(bool, PrintTerminationStats, false, \
1630 "Print termination statistics for parallel collectors") \
1631 \
1632 product(uintx, ParallelGCBufferWastePct, 10, \
1633 "Wasted fraction of parallel allocation buffer") \
1634 range(0, 100) \
1635 \
1636 product(uintx, TargetPLABWastePct, 10, \
1637 "Target wasted space in last buffer as percent of overall " \
1638 "allocation") \
1639 range(1, 100) \
1640 \
1641 product(uintx, PLABWeight, 75, \
1642 "Percentage (0-100) used to weight the current sample when " \
1643 "computing exponentially decaying average for ResizePLAB") \
1644 range(0, 100) \
1645 \
1646 product(bool, ResizePLAB, true, \
1647 "Dynamically resize (survivor space) promotion LAB's") \
1648 \
1649 product(bool, PrintPLAB, false, \
1650 "Print (survivor space) promotion LAB's sizing decisions") \
1651 \
1652 product(intx, ParGCArrayScanChunk, 50, \
1653 "Scan a subset of object array and push remainder, if array is " \
1654 "bigger than this") \
1655 range(1, max_intx) \
1656 \
1657 product(bool, ParGCUseLocalOverflow, false, \
1658 "Instead of a global overflow list, use local overflow stacks") \
1659 \
1660 product(bool, ParGCTrimOverflow, true, \
1661 "Eagerly trim the local overflow lists " \
1662 "(when ParGCUseLocalOverflow)") \
1663 \
1664 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1665 "Simulate work queue overflow in ParNew") \
1666 \
1667 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1668 "An `interval' counter that determines how frequently " \
1669 "we simulate overflow; a smaller number increases frequency") \
1670 \
1671 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1674 diagnostic(uintx, ParGCStridesPerThread, 2, \
1675 "The number of strides per worker thread that we divide up the " \
1676 "card table scanning work into") \
1677 range(1, max_uintx) \
1678 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1679 \
1680 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1681 "The number of cards in each chunk of the parallel chunks used " \
1682 "during card table scanning") \
1683 range(1, max_intx) \
1684 \
1685 product(uintx, OldPLABWeight, 50, \
1686 "Percentage (0-100) used to weight the current sample when " \
1687 "computing exponentially decaying average for resizing " \
1688 "OldPLABSize") \
1689 range(0, 100) \
1690 \
1691 product(bool, ResizeOldPLAB, true, \
1692 "Dynamically resize (old gen) promotion LAB's") \
1693 \
1694 product(bool, PrintOldPLAB, false, \
1695 "Print (old gen) promotion LAB's sizing decisions") \
1696 \
1697 product(size_t, CMSOldPLABMax, 1024, \
1698 "Maximum size of CMS gen promotion LAB caches per worker " \
1699 "per block size") \
1700 range(1, max_uintx) \
1701 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1702 \
1703 product(size_t, CMSOldPLABMin, 16, \
1704 "Minimum size of CMS gen promotion LAB caches per worker " \
1705 "per block size") \
1706 range(1, max_uintx) \
1707 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1708 \
1709 product(uintx, CMSOldPLABNumRefills, 4, \
1710 "Nominal number of refills of CMS gen promotion LAB cache " \
1711 "per worker per block size") \
1712 range(1, max_uintx) \
1713 \
1714 product(bool, CMSOldPLABResizeQuicker, false, \
1715 "React on-the-fly during a scavenge to a sudden " \
1716 "change in block demand rate") \
1868 "Whether abort-on-overflow semantics is implemented") \
1869 \
1870 product(bool, CMSParallelInitialMarkEnabled, true, \
1871 "Use the parallel initial mark.") \
1872 \
1873 product(bool, CMSParallelRemarkEnabled, true, \
1874 "Whether parallel remark enabled (only if ParNewGC)") \
1875 \
1876 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1877 "Whether parallel remark of survivor space " \
1878 "enabled (effective only if CMSParallelRemarkEnabled)") \
1879 \
1880 product(bool, CMSPLABRecordAlways, true, \
1881 "Always record survivor space PLAB boundaries (effective only " \
1882 "if CMSParallelSurvivorRemarkEnabled)") \
1883 \
1884 product(bool, CMSEdenChunksRecordAlways, true, \
1885 "Always record eden chunks used for the parallel initial mark " \
1886 "or remark of eden") \
1887 \
1888 product(bool, CMSPrintEdenSurvivorChunks, false, \
1889 "Print the eden and the survivor chunks used for the parallel " \
1890 "initial mark or remark of the eden/survivor spaces") \
1891 \
1892 product(bool, CMSConcurrentMTEnabled, true, \
1893 "Whether multi-threaded concurrent work enabled " \
1894 "(effective only if ParNewGC)") \
1895 \
1896 product(bool, CMSPrecleaningEnabled, true, \
1897 "Whether concurrent precleaning enabled") \
1898 \
1899 product(uintx, CMSPrecleanIter, 3, \
1900 "Maximum number of precleaning iteration passes") \
1901 range(0, 9) \
1902 \
1903 product(uintx, CMSPrecleanDenominator, 3, \
1904 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1905 "ratio") \
1906 range(1, max_uintx) \
1907 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1908 \
1909 product(uintx, CMSPrecleanNumerator, 2, \
1910 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1911 "ratio") \
1939 "If Eden size is below this, do not try to schedule remark") \
1940 \
1941 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1942 "The Eden occupancy percentage (0-100) at which " \
1943 "to try and schedule remark pause") \
1944 range(0, 100) \
1945 \
1946 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1947 "Start sampling eden top at least before young gen " \
1948 "occupancy reaches 1/<ratio> of the size at which " \
1949 "we plan to schedule remark") \
1950 range(1, max_uintx) \
1951 \
1952 product(uintx, CMSSamplingGrain, 16*K, \
1953 "The minimum distance between eden samples for CMS (see above)") \
1954 range(1, max_uintx) \
1955 \
1956 product(bool, CMSScavengeBeforeRemark, false, \
1957 "Attempt scavenge before the CMS remark step") \
1958 \
1959 develop(bool, CMSTraceSweeper, false, \
1960 "Trace some actions of the CMS sweeper") \
1961 \
1962 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1963 "Don't drain below this size per parallel worker/thief") \
1964 range(1, max_juint) \
1965 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1966 \
1967 manageable(intx, CMSWaitDuration, 2000, \
1968 "Time in milliseconds that CMS thread waits for young GC") \
1969 \
1970 develop(uintx, CMSCheckInterval, 1000, \
1971 "Interval in milliseconds that CMS thread checks if it " \
1972 "should start a collection cycle") \
1973 \
1974 product(bool, CMSYield, true, \
1975 "Yield between steps of CMS") \
1976 \
1977 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1978 "Bitmap operations should process at most this many bits " \
1979 "between yields") \
1980 range(1, max_uintx) \
1981 \
1982 product(bool, CMSDumpAtPromotionFailure, false, \
1983 "Dump useful information about the state of the CMS old " \
1984 "generation upon a promotion failure") \
1985 \
1986 product(bool, CMSPrintChunksInDump, false, \
1987 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1988 "more detailed information about the free chunks") \
1989 \
1990 product(bool, CMSPrintObjectsInDump, false, \
1991 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1992 "more detailed information about the allocated objects") \
1993 \
1994 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
1995 "Verify that all references across the FLS boundary " \
1996 "are to valid objects") \
1997 \
1998 diagnostic(bool, FLSVerifyLists, false, \
1999 "Do lots of (expensive) FreeListSpace verification") \
2000 \
2001 diagnostic(bool, FLSVerifyIndexTable, false, \
2002 "Do lots of (expensive) FLS index table verification") \
2003 \
2004 develop(bool, FLSVerifyDictionary, false, \
2005 "Do lots of (expensive) FLS dictionary verification") \
2006 \
2007 develop(bool, VerifyBlockOffsetArray, false, \
2008 "Do (expensive) block offset array verification") \
2009 \
2010 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
2011 "Maintain _unallocated_block in BlockOffsetArray " \
2012 "(currently applicable only to CMS collector)") \
2013 \
2014 develop(bool, TraceCMSState, false, \
2015 "Trace the state of the CMS collection") \
2016 \
2017 product(intx, RefDiscoveryPolicy, 0, \
2018 "Select type of reference discovery policy: " \
2019 "reference-based(0) or referent-based(1)") \
2020 range(ReferenceProcessor::DiscoveryPolicyMin, \
2021 ReferenceProcessor::DiscoveryPolicyMax) \
2022 \
2023 product(bool, ParallelRefProcEnabled, false, \
2024 "Enable parallel reference processing whenever possible") \
2025 \
2026 product(bool, ParallelRefProcBalancingEnabled, true, \
2027 "Enable balancing of reference processing queues") \
2028 \
2029 product(uintx, CMSTriggerRatio, 80, \
2030 "Percentage of MinHeapFreeRatio in CMS generation that is " \
2031 "allocated before a CMS collection cycle commences") \
2032 range(0, 100) \
2033 \
2034 product(uintx, CMSBootstrapOccupancy, 50, \
2035 "Percentage CMS generation occupancy at which to " \
2036 "initiate CMS collection for bootstrapping collection stats") \
2064 \
2065 develop(bool, CMSTestInFreeList, false, \
2066 "Check if the coalesced range is already in the " \
2067 "free lists as claimed") \
2068 \
2069 notproduct(bool, CMSVerifyReturnedBytes, false, \
2070 "Check that all the garbage collected was returned to the " \
2071 "free lists") \
2072 \
2073 notproduct(bool, ScavengeALot, false, \
2074 "Force scavenge at every Nth exit from the runtime system " \
2075 "(N=ScavengeALotInterval)") \
2076 \
2077 develop(bool, FullGCALot, false, \
2078 "Force full gc at every Nth exit from the runtime system " \
2079 "(N=FullGCALotInterval)") \
2080 \
2081 notproduct(bool, GCALotAtAllSafepoints, false, \
2082 "Enforce ScavengeALot/GCALot at all potential safepoints") \
2083 \
2084 product(bool, PrintPromotionFailure, false, \
2085 "Print additional diagnostic information following " \
2086 "promotion failure") \
2087 \
2088 notproduct(bool, PromotionFailureALot, false, \
2089 "Use promotion failure handling on every youngest generation " \
2090 "collection") \
2091 \
2092 develop(uintx, PromotionFailureALotCount, 1000, \
2093 "Number of promotion failures occurring at PLAB " \
2094 "refill attempts (ParNew) or promotion attempts " \
2095 "(other young collectors)") \
2096 \
2097 develop(uintx, PromotionFailureALotInterval, 5, \
2098 "Total collections between promotion failures a lot") \
2099 \
2100 experimental(uintx, WorkStealingSleepMillis, 1, \
2101 "Sleep time when sleep is used for yields") \
2102 \
2103 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
2104 "Number of yields before a sleep is done during work stealing") \
2105 \
2106 experimental(uintx, WorkStealingHardSpins, 4096, \
2107 "Number of iterations in a spin loop between checks on " \
2108 "time out of hard spin") \
2109 \
2110 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
2111 "Ratio of hard spins to calls to yield") \
2112 \
2113 develop(uintx, ObjArrayMarkingStride, 512, \
2114 "Number of object array elements to push onto the marking stack " \
2115 "before pushing a continuation entry") \
2116 \
2117 develop(bool, MetadataAllocationFailALot, false, \
2118 "Fail metadata allocations at intervals controlled by " \
2119 "MetadataAllocationFailALotInterval") \
2120 \
2121 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
2122 "Metadata allocation failure a lot interval") \
2123 \
2124 develop(bool, TraceMetadataChunkAllocation, false, \
2125 "Trace chunk metadata allocations") \
2126 \
2127 product(bool, TraceMetadataHumongousAllocation, false, \
2128 "Trace humongous metadata allocations") \
2129 \
2130 develop(bool, TraceMetavirtualspaceAllocation, false, \
2131 "Trace virtual space metadata allocations") \
2132 \
2133 notproduct(bool, ExecuteInternalVMTests, false, \
2134 "Enable execution of internal VM tests") \
2135 \
2136 notproduct(bool, VerboseInternalVMTests, false, \
2137 "Turn on logging for internal VM tests.") \
2138 \
2139 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
2140 \
2141 product_pd(bool, ResizeTLAB, \
2142 "Dynamically resize TLAB size for threads") \
2143 \
2144 product(bool, ZeroTLAB, false, \
2145 "Zero out the newly created TLAB") \
2146 \
2147 product(bool, FastTLABRefill, true, \
2148 "Use fast TLAB refill code") \
2149 \
2150 product(bool, PrintTLAB, false, \
2151 "Print various TLAB related information") \
2152 \
2153 product(bool, TLABStats, true, \
2154 "Provide more detailed and expensive TLAB statistics " \
2155 "(with PrintTLAB)") \
2156 \
2157 product_pd(bool, NeverActAsServerClassMachine, \
2158 "Never act like a server-class machine") \
2159 \
2160 product(bool, AlwaysActAsServerClassMachine, false, \
2161 "Always act like a server-class machine") \
2162 \
2163 product_pd(uint64_t, MaxRAM, \
2164 "Real memory size (in bytes) used to set maximum heap size") \
2165 range(0, 0XFFFFFFFFFFFFFFFF) \
2166 \
2167 product(size_t, ErgoHeapSizeLimit, 0, \
2168 "Maximum ergonomically set heap size (in bytes); zero means use " \
2169 "MaxRAM / MaxRAMFraction") \
2170 \
2171 product(uintx, MaxRAMFraction, 4, \
2172 "Maximum fraction (1/n) of real memory used for maximum heap " \
2173 "size") \
2174 range(1, max_uintx) \
2175 \
2193 "Automatic GC selection pause threshold in milliseconds") \
2194 \
2195 product(bool, UseAdaptiveSizePolicy, true, \
2196 "Use adaptive generation sizing policies") \
2197 \
2198 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2199 "Use adaptive survivor sizing policies") \
2200 \
2201 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2202 "Use adaptive young-old sizing policies at minor collections") \
2203 \
2204 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2205 "Use adaptive young-old sizing policies at major collections") \
2206 \
2207 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2208 "Include statistics from System.gc() for adaptive size policy") \
2209 \
2210 product(bool, UseAdaptiveGCBoundary, false, \
2211 "Allow young-old boundary to move") \
2212 \
2213 develop(bool, TraceAdaptiveGCBoundary, false, \
2214 "Trace young-old boundary moves") \
2215 \
2216 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2217 "Resize the virtual spaces of the young or old generations") \
2218 range(-1, 1) \
2219 \
2220 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2221 "Policy for changing generation size for throughput goals") \
2222 range(0, 1) \
2223 \
2224 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2225 "Number of steps where heuristics is used before data is used") \
2226 \
2227 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2228 "Number of collections before the adaptive sizing is started") \
2229 \
2230 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2231 "Collection interval for printing information; zero means never") \
2232 \
2233 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2234 "Use adaptive minimum footprint as a goal") \
2235 \
2320 "Estimate of footprint other than Java Heap") \
2321 \
2322 product(bool, UseGCOverheadLimit, true, \
2323 "Use policy to limit of proportion of time spent in GC " \
2324 "before an OutOfMemory error is thrown") \
2325 \
2326 product(uintx, GCTimeLimit, 98, \
2327 "Limit of the proportion of time spent in GC before " \
2328 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2329 range(0, 100) \
2330 \
2331 product(uintx, GCHeapFreeLimit, 2, \
2332 "Minimum percentage of free space after a full GC before an " \
2333 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2334 range(0, 100) \
2335 \
2336 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2337 "Number of consecutive collections before gc time limit fires") \
2338 range(1, max_uintx) \
2339 \
2340 product(bool, PrintAdaptiveSizePolicy, false, \
2341 "Print information about AdaptiveSizePolicy") \
2342 \
2343 product(intx, PrefetchCopyIntervalInBytes, -1, \
2344 "How far ahead to prefetch destination area (<= 0 means off)") \
2345 \
2346 product(intx, PrefetchScanIntervalInBytes, -1, \
2347 "How far ahead to prefetch scan area (<= 0 means off)") \
2348 \
2349 product(intx, PrefetchFieldsAhead, -1, \
2350 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2351 \
2352 diagnostic(bool, VerifySilently, false, \
2353 "Do not print the verification progress") \
2354 \
2355 diagnostic(bool, VerifyDuringStartup, false, \
2356 "Verify memory system before executing any Java code " \
2357 "during VM initialization") \
2358 \
2359 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2360 "Verify system before exiting") \
2361 \
2362 diagnostic(bool, VerifyBeforeGC, false, \
2363 "Verify memory system before GC") \
2364 \
2365 diagnostic(bool, VerifyAfterGC, false, \
2366 "Verify memory system after GC") \
2367 \
2368 diagnostic(bool, VerifyDuringGC, false, \
2369 "Verify memory system during GC (between phases)") \
2370 \
2371 diagnostic(bool, GCParallelVerificationEnabled, true, \
2372 "Enable parallel memory system verification") \
2373 \
2374 diagnostic(bool, DeferInitialCardMark, false, \
2396 diagnostic(uintx, CPUForCMSThread, 0, \
2397 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2398 \
2399 product(bool, BindGCTaskThreadsToCPUs, false, \
2400 "Bind GCTaskThreads to CPUs if possible") \
2401 \
2402 product(bool, UseGCTaskAffinity, false, \
2403 "Use worker affinity when asking for GCTasks") \
2404 \
2405 product(uintx, ProcessDistributionStride, 4, \
2406 "Stride through processors when distributing processes") \
2407 \
2408 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2409 "Number of times the coordinator GC thread will sleep while " \
2410 "yielding before giving up and resuming GC") \
2411 \
2412 product(uintx, CMSYieldSleepCount, 0, \
2413 "Number of times a GC thread (minus the coordinator) " \
2414 "will sleep while yielding before giving up and resuming GC") \
2415 \
2416 /* gc tracing */ \
2417 manageable(bool, PrintGC, false, \
2418 "Print message at garbage collection") \
2419 \
2420 manageable(bool, PrintGCDetails, false, \
2421 "Print more details at garbage collection") \
2422 \
2423 manageable(bool, PrintGCDateStamps, false, \
2424 "Print date stamps at garbage collection") \
2425 \
2426 manageable(bool, PrintGCTimeStamps, false, \
2427 "Print timestamps at garbage collection") \
2428 \
2429 manageable(bool, PrintGCID, true, \
2430 "Print an identifier for each garbage collection") \
2431 \
2432 product(bool, PrintGCTaskTimeStamps, false, \
2433 "Print timestamps for individual gc worker thread tasks") \
2434 \
2435 develop(intx, ConcGCYieldTimeout, 0, \
2436 "If non-zero, assert that GC threads yield within this " \
2437 "number of milliseconds") \
2438 range(0, max_intx) \
2439 \
2440 product(bool, PrintReferenceGC, false, \
2441 "Print times spent handling reference objects during GC " \
2442 "(enabled only when PrintGCDetails)") \
2443 \
2444 develop(bool, TraceReferenceGC, false, \
2445 "Trace handling of soft/weak/final/phantom references") \
2446 \
2447 develop(bool, TraceFinalizerRegistration, false, \
2448 "Trace registration of final references") \
2449 \
2450 notproduct(bool, TraceScavenge, false, \
2451 "Trace scavenge") \
2452 \
2453 product(bool, IgnoreEmptyClassPaths, false, \
2454 "Ignore empty path elements in -classpath") \
2455 \
2456 product(bool, TraceClassPaths, false, \
2457 "Trace processing of class paths") \
2458 \
2459 product_rw(bool, TraceClassLoading, false, \
2460 "Trace all classes loaded") \
2461 \
2462 product(bool, TraceClassLoadingPreorder, false, \
2463 "Trace all classes loaded in order referenced (not loaded)") \
2464 \
2465 product_rw(bool, TraceClassUnloading, false, \
2466 "Trace unloading of classes") \
2467 \
2468 product_rw(bool, TraceLoaderConstraints, false, \
2469 "Trace loader constraints") \
2470 \
2471 develop(bool, TraceClassLoaderData, false, \
2472 "Trace class loader loader_data lifetime") \
2473 \
2474 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2475 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2476 "Initial size of the boot class loader data metaspace") \
2477 range(30*K, max_uintx/BytesPerWord) \
2478 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2479 \
2480 product(bool, TraceYoungGenTime, false, \
2481 "Trace accumulated time for young collection") \
2482 \
2483 product(bool, TraceOldGenTime, false, \
2484 "Trace accumulated time for old collection") \
2485 \
2486 product(bool, PrintTenuringDistribution, false, \
2487 "Print tenuring age information") \
2488 \
2489 product_rw(bool, PrintHeapAtGC, false, \
2490 "Print heap layout before and after each GC") \
2491 \
2492 product_rw(bool, PrintHeapAtGCExtended, false, \
2493 "Print extended information about the layout of the heap " \
2494 "when -XX:+PrintHeapAtGC is set") \
2495 \
2496 product(bool, PrintHeapAtSIGBREAK, true, \
2497 "Print heap layout in response to SIGBREAK") \
2498 \
2499 manageable(bool, PrintClassHistogramBeforeFullGC, false, \
2500 "Print a class histogram before any major stop-world GC") \
2501 \
2502 manageable(bool, PrintClassHistogramAfterFullGC, false, \
2503 "Print a class histogram after any major stop-world GC") \
2504 \
2505 manageable(bool, PrintClassHistogram, false, \
2506 "Print a histogram of class instances") \
2507 \
2508 develop(bool, TraceWorkGang, false, \
2509 "Trace activities of work gangs") \
2510 \
2511 develop(bool, TraceBlockOffsetTable, false, \
2512 "Print BlockOffsetTable maps") \
2513 \
2514 develop(bool, TraceCardTableModRefBS, false, \
2515 "Print CardTableModRefBS maps") \
2516 \
2517 develop(bool, TraceGCTaskManager, false, \
2518 "Trace actions of the GC task manager") \
2519 \
2520 develop(bool, TraceGCTaskQueue, false, \
2521 "Trace actions of the GC task queues") \
2522 \
2523 diagnostic(bool, TraceGCTaskThread, false, \
2524 "Trace actions of the GC task threads") \
2525 \
2526 product(bool, PrintParallelOldGCPhaseTimes, false, \
2527 "Print the time taken by each phase in ParallelOldGC " \
2528 "(PrintGCDetails must also be enabled)") \
2529 \
2530 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2531 "Trace marking phase in ParallelOldGC") \
2532 \
2533 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2534 "Trace summary phase in ParallelOldGC") \
2535 \
2536 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2537 "Trace compaction phase in ParallelOldGC") \
2538 \
2539 develop(bool, TraceParallelOldGCDensePrefix, false, \
2540 "Trace dense prefix computation for ParallelOldGC") \
2541 \
2542 develop(bool, IgnoreLibthreadGPFault, false, \
2543 "Suppress workaround for libthread GP fault") \
2544 \
2545 product(bool, PrintJNIGCStalls, false, \
2546 "Print diagnostic message when GC is stalled " \
2547 "by JNI critical section") \
2548 \
2549 experimental(double, ObjectCountCutOffPercent, 0.5, \
2550 "The percentage of the used heap that the instances of a class " \
2551 "must occupy for the class to generate a trace event") \
2552 range(0.0, 100.0) \
2553 \
2554 /* GC log rotation setting */ \
2555 \
2556 product(bool, UseGCLogFileRotation, false, \
2557 "Rotate gclog files (for long running applications). It requires "\
2558 "-Xloggc:<filename>") \
2559 \
2560 product(uintx, NumberOfGCLogFiles, 0, \
2561 "Number of gclog files in rotation " \
2562 "(default: 0, no rotation)") \
2563 \
2564 product(size_t, GCLogFileSize, 8*K, \
2565 "GC log file size, requires UseGCLogFileRotation. " \
2566 "Set to 0 to only trigger rotation via jcmd") \
2567 \
2568 /* JVMTI heap profiling */ \
2569 \
2570 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2571 "Trace JVMTI object tagging calls") \
2572 \
2573 diagnostic(bool, VerifyBeforeIteration, false, \
2574 "Verify memory system before JVMTI iteration") \
2575 \
2576 /* compiler interface */ \
2577 \
2578 develop(bool, CIPrintCompilerName, false, \
2579 "when CIPrint is active, print the name of the active compiler") \
2580 \
2581 diagnostic(bool, CIPrintCompileQueue, false, \
2582 "display the contents of the compile queue whenever a " \
2583 "compilation is enqueued") \
2584 \
2585 develop(bool, CIPrintRequests, false, \
2586 "display every request for compilation") \
2587 \
3469 product(uintx, TargetSurvivorRatio, 50, \
3470 "Desired percentage of survivor space used after scavenge") \
3471 range(0, 100) \
3472 \
3473 product(uintx, MarkSweepDeadRatio, 5, \
3474 "Percentage (0-100) of the old gen allowed as dead wood. " \
3475 "Serial mark sweep treats this as both the minimum and maximum " \
3476 "value. " \
3477 "CMS uses this value only if it falls back to mark sweep. " \
3478 "Par compact uses a variable scale based on the density of the " \
3479 "generation and treats this as the maximum value when the heap " \
3480 "is either completely full or completely empty. Par compact " \
3481 "also has a smaller default value; see arguments.cpp.") \
3482 range(0, 100) \
3483 \
3484 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3485 "How often should we fully compact the heap (ignoring the dead " \
3486 "space parameters)") \
3487 range(1, max_uintx) \
3488 \
3489 product(intx, PrintCMSStatistics, 0, \
3490 "Statistics for CMS") \
3491 \
3492 product(bool, PrintCMSInitiationStatistics, false, \
3493 "Statistics for initiating a CMS collection") \
3494 \
3495 product(intx, PrintFLSStatistics, 0, \
3496 "Statistics for CMS' FreeListSpace") \
3497 \
3498 product(intx, PrintFLSCensus, 0, \
3499 "Census for CMS' FreeListSpace") \
3500 \
3501 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3502 "Delay between expansion and allocation (in milliseconds)") \
3503 \
3504 develop(uintx, GCWorkerDelayMillis, 0, \
3505 "Delay in scheduling GC workers (in milliseconds)") \
3506 \
3507 product(intx, DeferThrSuspendLoopCount, 4000, \
3508 "(Unstable) Number of times to iterate in safepoint loop " \
3509 "before blocking VM threads ") \
3510 range(-1, max_jint-1) \
3511 \
3512 product(intx, DeferPollingPageLoopCount, -1, \
3513 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3514 "before changing safepoint polling page to RO ") \
3515 range(-1, max_jint-1) \
3516 \
3517 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3518 range(0, max_intx) \
3519 \
3520 product(bool, PSChunkLargeArrays, true, \
4174 product(bool, DTraceAllocProbes, false, \
4175 "Enable dtrace probes for object allocation") \
4176 \
4177 product(bool, DTraceMonitorProbes, false, \
4178 "Enable dtrace probes for monitor events") \
4179 \
4180 product(bool, RelaxAccessControlCheck, false, \
4181 "Relax the access control checks in the verifier") \
4182 \
4183 product(uintx, StringTableSize, defaultStringTableSize, \
4184 "Number of buckets in the interned String table") \
4185 range(minimumStringTableSize, 111*defaultStringTableSize) \
4186 \
4187 experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
4188 "Number of buckets in the JVM internal Symbol table") \
4189 range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \
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)") \
1545 "Number of parallel threads parallel gc will use") \
1546 constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
1547 \
1548 diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
1549 "Use semaphore synchronization for the GC Threads, " \
1550 "instead of synchronization based on mutexes") \
1551 \
1552 product(bool, UseDynamicNumberOfGCThreads, false, \
1553 "Dynamically choose the number of parallel threads " \
1554 "parallel gc will use") \
1555 \
1556 diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
1557 "Force dynamic selection of the number of " \
1558 "parallel threads parallel gc will use to aid debugging") \
1559 \
1560 product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
1561 "Size of heap (bytes) per GC thread used in calculating the " \
1562 "number of GC threads") \
1563 range((size_t)os::vm_page_size(), (size_t)max_uintx) \
1564 \
1565 product(uint, ConcGCThreads, 0, \
1566 "Number of threads concurrent gc will use") \
1567 constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
1568 \
1569 product(uintx, GCTaskTimeStampEntries, 200, \
1570 "Number of time stamp entries per gc worker thread") \
1571 range(1, max_uintx) \
1572 \
1573 product(bool, AlwaysTenure, false, \
1574 "Always tenure objects in eden (ParallelGC only)") \
1575 \
1576 product(bool, NeverTenure, false, \
1577 "Never tenure objects in eden, may tenure on overflow " \
1578 "(ParallelGC only)") \
1579 \
1580 product(bool, ScavengeBeforeFullGC, true, \
1581 "Scavenge youngest generation before each full GC.") \
1582 \
1583 product(bool, UseConcMarkSweepGC, false, \
1584 "Use Concurrent Mark-Sweep GC in the old generation") \
1594 \
1595 product(bool, GCLockerInvokesConcurrent, false, \
1596 "The exit of a JNI critical section necessitating a scavenge, " \
1597 "also kicks off a background concurrent collection") \
1598 \
1599 product(uintx, GCLockerEdenExpansionPercent, 5, \
1600 "How much the GC can expand the eden by while the GC locker " \
1601 "is active (as a percentage)") \
1602 range(0, 100) \
1603 \
1604 diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
1605 "Number of times to retry allocations when " \
1606 "blocked by the GC locker") \
1607 \
1608 product(bool, UseCMSBestFit, true, \
1609 "Use CMS best fit allocation strategy") \
1610 \
1611 product(bool, UseParNewGC, false, \
1612 "Use parallel threads in the new generation") \
1613 \
1614 product(uintx, ParallelGCBufferWastePct, 10, \
1615 "Wasted fraction of parallel allocation buffer") \
1616 range(0, 100) \
1617 \
1618 product(uintx, TargetPLABWastePct, 10, \
1619 "Target wasted space in last buffer as percent of overall " \
1620 "allocation") \
1621 range(1, 100) \
1622 \
1623 product(uintx, PLABWeight, 75, \
1624 "Percentage (0-100) used to weight the current sample when " \
1625 "computing exponentially decaying average for ResizePLAB") \
1626 range(0, 100) \
1627 \
1628 product(bool, ResizePLAB, true, \
1629 "Dynamically resize (survivor space) promotion LAB's") \
1630 \
1631 product(intx, ParGCArrayScanChunk, 50, \
1632 "Scan a subset of object array and push remainder, if array is " \
1633 "bigger than this") \
1634 range(1, max_intx) \
1635 \
1636 product(bool, ParGCUseLocalOverflow, false, \
1637 "Instead of a global overflow list, use local overflow stacks") \
1638 \
1639 product(bool, ParGCTrimOverflow, true, \
1640 "Eagerly trim the local overflow lists " \
1641 "(when ParGCUseLocalOverflow)") \
1642 \
1643 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1644 "Simulate work queue overflow in ParNew") \
1645 \
1646 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1647 "An `interval' counter that determines how frequently " \
1648 "we simulate overflow; a smaller number increases frequency") \
1649 \
1650 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1653 diagnostic(uintx, ParGCStridesPerThread, 2, \
1654 "The number of strides per worker thread that we divide up the " \
1655 "card table scanning work into") \
1656 range(1, max_uintx) \
1657 constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
1658 \
1659 diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
1660 "The number of cards in each chunk of the parallel chunks used " \
1661 "during card table scanning") \
1662 range(1, max_intx) \
1663 \
1664 product(uintx, OldPLABWeight, 50, \
1665 "Percentage (0-100) used to weight the current sample when " \
1666 "computing exponentially decaying average for resizing " \
1667 "OldPLABSize") \
1668 range(0, 100) \
1669 \
1670 product(bool, ResizeOldPLAB, true, \
1671 "Dynamically resize (old gen) promotion LAB's") \
1672 \
1673 product(size_t, CMSOldPLABMax, 1024, \
1674 "Maximum size of CMS gen promotion LAB caches per worker " \
1675 "per block size") \
1676 range(1, max_uintx) \
1677 constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
1678 \
1679 product(size_t, CMSOldPLABMin, 16, \
1680 "Minimum size of CMS gen promotion LAB caches per worker " \
1681 "per block size") \
1682 range(1, max_uintx) \
1683 constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
1684 \
1685 product(uintx, CMSOldPLABNumRefills, 4, \
1686 "Nominal number of refills of CMS gen promotion LAB cache " \
1687 "per worker per block size") \
1688 range(1, max_uintx) \
1689 \
1690 product(bool, CMSOldPLABResizeQuicker, false, \
1691 "React on-the-fly during a scavenge to a sudden " \
1692 "change in block demand rate") \
1844 "Whether abort-on-overflow semantics is implemented") \
1845 \
1846 product(bool, CMSParallelInitialMarkEnabled, true, \
1847 "Use the parallel initial mark.") \
1848 \
1849 product(bool, CMSParallelRemarkEnabled, true, \
1850 "Whether parallel remark enabled (only if ParNewGC)") \
1851 \
1852 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1853 "Whether parallel remark of survivor space " \
1854 "enabled (effective only if CMSParallelRemarkEnabled)") \
1855 \
1856 product(bool, CMSPLABRecordAlways, true, \
1857 "Always record survivor space PLAB boundaries (effective only " \
1858 "if CMSParallelSurvivorRemarkEnabled)") \
1859 \
1860 product(bool, CMSEdenChunksRecordAlways, true, \
1861 "Always record eden chunks used for the parallel initial mark " \
1862 "or remark of eden") \
1863 \
1864 product(bool, CMSConcurrentMTEnabled, true, \
1865 "Whether multi-threaded concurrent work enabled " \
1866 "(effective only if ParNewGC)") \
1867 \
1868 product(bool, CMSPrecleaningEnabled, true, \
1869 "Whether concurrent precleaning enabled") \
1870 \
1871 product(uintx, CMSPrecleanIter, 3, \
1872 "Maximum number of precleaning iteration passes") \
1873 range(0, 9) \
1874 \
1875 product(uintx, CMSPrecleanDenominator, 3, \
1876 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1877 "ratio") \
1878 range(1, max_uintx) \
1879 constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo) \
1880 \
1881 product(uintx, CMSPrecleanNumerator, 2, \
1882 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
1883 "ratio") \
1911 "If Eden size is below this, do not try to schedule remark") \
1912 \
1913 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1914 "The Eden occupancy percentage (0-100) at which " \
1915 "to try and schedule remark pause") \
1916 range(0, 100) \
1917 \
1918 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1919 "Start sampling eden top at least before young gen " \
1920 "occupancy reaches 1/<ratio> of the size at which " \
1921 "we plan to schedule remark") \
1922 range(1, max_uintx) \
1923 \
1924 product(uintx, CMSSamplingGrain, 16*K, \
1925 "The minimum distance between eden samples for CMS (see above)") \
1926 range(1, max_uintx) \
1927 \
1928 product(bool, CMSScavengeBeforeRemark, false, \
1929 "Attempt scavenge before the CMS remark step") \
1930 \
1931 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1932 "Don't drain below this size per parallel worker/thief") \
1933 range(1, max_juint) \
1934 constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
1935 \
1936 manageable(intx, CMSWaitDuration, 2000, \
1937 "Time in milliseconds that CMS thread waits for young GC") \
1938 \
1939 develop(uintx, CMSCheckInterval, 1000, \
1940 "Interval in milliseconds that CMS thread checks if it " \
1941 "should start a collection cycle") \
1942 \
1943 product(bool, CMSYield, true, \
1944 "Yield between steps of CMS") \
1945 \
1946 product(size_t, CMSBitMapYieldQuantum, 10*M, \
1947 "Bitmap operations should process at most this many bits " \
1948 "between yields") \
1949 range(1, max_uintx) \
1950 \
1951 product(bool, CMSPrintChunksInDump, false, \
1952 "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
1953 "trace level include more detailed information about the" \
1954 "free chunks") \
1955 \
1956 product(bool, CMSPrintObjectsInDump, false, \
1957 "If logging for the \"gc\" and \"promotion\" tags is enabled on" \
1958 "trace level include more detailed information about the" \
1959 "allocated objects") \
1960 \
1961 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
1962 "Verify that all references across the FLS boundary " \
1963 "are to valid objects") \
1964 \
1965 diagnostic(bool, FLSVerifyLists, false, \
1966 "Do lots of (expensive) FreeListSpace verification") \
1967 \
1968 diagnostic(bool, FLSVerifyIndexTable, false, \
1969 "Do lots of (expensive) FLS index table verification") \
1970 \
1971 develop(bool, FLSVerifyDictionary, false, \
1972 "Do lots of (expensive) FLS dictionary verification") \
1973 \
1974 develop(bool, VerifyBlockOffsetArray, false, \
1975 "Do (expensive) block offset array verification") \
1976 \
1977 diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
1978 "Maintain _unallocated_block in BlockOffsetArray " \
1979 "(currently applicable only to CMS collector)") \
1980 \
1981 product(intx, RefDiscoveryPolicy, 0, \
1982 "Select type of reference discovery policy: " \
1983 "reference-based(0) or referent-based(1)") \
1984 range(ReferenceProcessor::DiscoveryPolicyMin, \
1985 ReferenceProcessor::DiscoveryPolicyMax) \
1986 \
1987 product(bool, ParallelRefProcEnabled, false, \
1988 "Enable parallel reference processing whenever possible") \
1989 \
1990 product(bool, ParallelRefProcBalancingEnabled, true, \
1991 "Enable balancing of reference processing queues") \
1992 \
1993 product(uintx, CMSTriggerRatio, 80, \
1994 "Percentage of MinHeapFreeRatio in CMS generation that is " \
1995 "allocated before a CMS collection cycle commences") \
1996 range(0, 100) \
1997 \
1998 product(uintx, CMSBootstrapOccupancy, 50, \
1999 "Percentage CMS generation occupancy at which to " \
2000 "initiate CMS collection for bootstrapping collection stats") \
2028 \
2029 develop(bool, CMSTestInFreeList, false, \
2030 "Check if the coalesced range is already in the " \
2031 "free lists as claimed") \
2032 \
2033 notproduct(bool, CMSVerifyReturnedBytes, false, \
2034 "Check that all the garbage collected was returned to the " \
2035 "free lists") \
2036 \
2037 notproduct(bool, ScavengeALot, false, \
2038 "Force scavenge at every Nth exit from the runtime system " \
2039 "(N=ScavengeALotInterval)") \
2040 \
2041 develop(bool, FullGCALot, false, \
2042 "Force full gc at every Nth exit from the runtime system " \
2043 "(N=FullGCALotInterval)") \
2044 \
2045 notproduct(bool, GCALotAtAllSafepoints, false, \
2046 "Enforce ScavengeALot/GCALot at all potential safepoints") \
2047 \
2048 notproduct(bool, PromotionFailureALot, false, \
2049 "Use promotion failure handling on every youngest generation " \
2050 "collection") \
2051 \
2052 develop(uintx, PromotionFailureALotCount, 1000, \
2053 "Number of promotion failures occurring at PLAB " \
2054 "refill attempts (ParNew) or promotion attempts " \
2055 "(other young collectors)") \
2056 \
2057 develop(uintx, PromotionFailureALotInterval, 5, \
2058 "Total collections between promotion failures a lot") \
2059 \
2060 experimental(uintx, WorkStealingSleepMillis, 1, \
2061 "Sleep time when sleep is used for yields") \
2062 \
2063 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000, \
2064 "Number of yields before a sleep is done during work stealing") \
2065 \
2066 experimental(uintx, WorkStealingHardSpins, 4096, \
2067 "Number of iterations in a spin loop between checks on " \
2068 "time out of hard spin") \
2069 \
2070 experimental(uintx, WorkStealingSpinToYieldRatio, 10, \
2071 "Ratio of hard spins to calls to yield") \
2072 \
2073 develop(uintx, ObjArrayMarkingStride, 512, \
2074 "Number of object array elements to push onto the marking stack " \
2075 "before pushing a continuation entry") \
2076 \
2077 develop(bool, MetadataAllocationFailALot, false, \
2078 "Fail metadata allocations at intervals controlled by " \
2079 "MetadataAllocationFailALotInterval") \
2080 \
2081 develop(uintx, MetadataAllocationFailALotInterval, 1000, \
2082 "Metadata allocation failure a lot interval") \
2083 \
2084 develop(bool, TraceMetadataChunkAllocation, false, \
2085 "Trace chunk metadata allocations") \
2086 \
2087 notproduct(bool, ExecuteInternalVMTests, false, \
2088 "Enable execution of internal VM tests") \
2089 \
2090 notproduct(bool, VerboseInternalVMTests, false, \
2091 "Turn on logging for internal VM tests.") \
2092 \
2093 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
2094 \
2095 product_pd(bool, ResizeTLAB, \
2096 "Dynamically resize TLAB size for threads") \
2097 \
2098 product(bool, ZeroTLAB, false, \
2099 "Zero out the newly created TLAB") \
2100 \
2101 product(bool, FastTLABRefill, true, \
2102 "Use fast TLAB refill code") \
2103 \
2104 product(bool, TLABStats, true, \
2105 "Provide more detailed and expensive TLAB statistics.") \
2106 \
2107 product_pd(bool, NeverActAsServerClassMachine, \
2108 "Never act like a server-class machine") \
2109 \
2110 product(bool, AlwaysActAsServerClassMachine, false, \
2111 "Always act like a server-class machine") \
2112 \
2113 product_pd(uint64_t, MaxRAM, \
2114 "Real memory size (in bytes) used to set maximum heap size") \
2115 range(0, 0XFFFFFFFFFFFFFFFF) \
2116 \
2117 product(size_t, ErgoHeapSizeLimit, 0, \
2118 "Maximum ergonomically set heap size (in bytes); zero means use " \
2119 "MaxRAM / MaxRAMFraction") \
2120 \
2121 product(uintx, MaxRAMFraction, 4, \
2122 "Maximum fraction (1/n) of real memory used for maximum heap " \
2123 "size") \
2124 range(1, max_uintx) \
2125 \
2143 "Automatic GC selection pause threshold in milliseconds") \
2144 \
2145 product(bool, UseAdaptiveSizePolicy, true, \
2146 "Use adaptive generation sizing policies") \
2147 \
2148 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
2149 "Use adaptive survivor sizing policies") \
2150 \
2151 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
2152 "Use adaptive young-old sizing policies at minor collections") \
2153 \
2154 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
2155 "Use adaptive young-old sizing policies at major collections") \
2156 \
2157 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
2158 "Include statistics from System.gc() for adaptive size policy") \
2159 \
2160 product(bool, UseAdaptiveGCBoundary, false, \
2161 "Allow young-old boundary to move") \
2162 \
2163 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
2164 "Resize the virtual spaces of the young or old generations") \
2165 range(-1, 1) \
2166 \
2167 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
2168 "Policy for changing generation size for throughput goals") \
2169 range(0, 1) \
2170 \
2171 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
2172 "Number of steps where heuristics is used before data is used") \
2173 \
2174 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
2175 "Number of collections before the adaptive sizing is started") \
2176 \
2177 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
2178 "Collection interval for printing information; zero means never") \
2179 \
2180 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
2181 "Use adaptive minimum footprint as a goal") \
2182 \
2267 "Estimate of footprint other than Java Heap") \
2268 \
2269 product(bool, UseGCOverheadLimit, true, \
2270 "Use policy to limit of proportion of time spent in GC " \
2271 "before an OutOfMemory error is thrown") \
2272 \
2273 product(uintx, GCTimeLimit, 98, \
2274 "Limit of the proportion of time spent in GC before " \
2275 "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
2276 range(0, 100) \
2277 \
2278 product(uintx, GCHeapFreeLimit, 2, \
2279 "Minimum percentage of free space after a full GC before an " \
2280 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2281 range(0, 100) \
2282 \
2283 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2284 "Number of consecutive collections before gc time limit fires") \
2285 range(1, max_uintx) \
2286 \
2287 product(intx, PrefetchCopyIntervalInBytes, -1, \
2288 "How far ahead to prefetch destination area (<= 0 means off)") \
2289 \
2290 product(intx, PrefetchScanIntervalInBytes, -1, \
2291 "How far ahead to prefetch scan area (<= 0 means off)") \
2292 \
2293 product(intx, PrefetchFieldsAhead, -1, \
2294 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2295 \
2296 diagnostic(bool, VerifyDuringStartup, false, \
2297 "Verify memory system before executing any Java code " \
2298 "during VM initialization") \
2299 \
2300 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2301 "Verify system before exiting") \
2302 \
2303 diagnostic(bool, VerifyBeforeGC, false, \
2304 "Verify memory system before GC") \
2305 \
2306 diagnostic(bool, VerifyAfterGC, false, \
2307 "Verify memory system after GC") \
2308 \
2309 diagnostic(bool, VerifyDuringGC, false, \
2310 "Verify memory system during GC (between phases)") \
2311 \
2312 diagnostic(bool, GCParallelVerificationEnabled, true, \
2313 "Enable parallel memory system verification") \
2314 \
2315 diagnostic(bool, DeferInitialCardMark, false, \
2337 diagnostic(uintx, CPUForCMSThread, 0, \
2338 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2339 \
2340 product(bool, BindGCTaskThreadsToCPUs, false, \
2341 "Bind GCTaskThreads to CPUs if possible") \
2342 \
2343 product(bool, UseGCTaskAffinity, false, \
2344 "Use worker affinity when asking for GCTasks") \
2345 \
2346 product(uintx, ProcessDistributionStride, 4, \
2347 "Stride through processors when distributing processes") \
2348 \
2349 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2350 "Number of times the coordinator GC thread will sleep while " \
2351 "yielding before giving up and resuming GC") \
2352 \
2353 product(uintx, CMSYieldSleepCount, 0, \
2354 "Number of times a GC thread (minus the coordinator) " \
2355 "will sleep while yielding before giving up and resuming GC") \
2356 \
2357 develop(intx, ConcGCYieldTimeout, 0, \
2358 "If non-zero, assert that GC threads yield within this " \
2359 "number of milliseconds") \
2360 range(0, max_intx) \
2361 \
2362 develop(bool, TraceFinalizerRegistration, false, \
2363 "Trace registration of final references") \
2364 \
2365 notproduct(bool, TraceScavenge, false, \
2366 "Trace scavenge") \
2367 \
2368 product(bool, IgnoreEmptyClassPaths, false, \
2369 "Ignore empty path elements in -classpath") \
2370 \
2371 product(bool, TraceClassPaths, false, \
2372 "Trace processing of class paths") \
2373 \
2374 product_rw(bool, TraceClassLoading, false, \
2375 "Trace all classes loaded") \
2376 \
2377 product(bool, TraceClassLoadingPreorder, false, \
2378 "Trace all classes loaded in order referenced (not loaded)") \
2379 \
2380 product_rw(bool, TraceClassUnloading, false, \
2381 "Trace unloading of classes") \
2382 \
2383 product_rw(bool, TraceLoaderConstraints, false, \
2384 "Trace loader constraints") \
2385 \
2386 develop(bool, TraceClassLoaderData, false, \
2387 "Trace class loader loader_data lifetime") \
2388 \
2389 product(size_t, InitialBootClassLoaderMetaspaceSize, \
2390 NOT_LP64(2200*K) LP64_ONLY(4*M), \
2391 "Initial size of the boot class loader data metaspace") \
2392 range(30*K, max_uintx/BytesPerWord) \
2393 constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2394 \
2395 product(bool, TraceYoungGenTime, false, \
2396 "Trace accumulated time for young collection") \
2397 \
2398 product(bool, TraceOldGenTime, false, \
2399 "Trace accumulated time for old collection") \
2400 \
2401 product(bool, PrintHeapAtSIGBREAK, true, \
2402 "Print heap layout in response to SIGBREAK") \
2403 \
2404 manageable(bool, PrintClassHistogram, false, \
2405 "Print a histogram of class instances") \
2406 \
2407 develop(bool, TraceWorkGang, false, \
2408 "Trace activities of work gangs") \
2409 \
2410 develop(bool, TraceGCTaskManager, false, \
2411 "Trace actions of the GC task manager") \
2412 \
2413 develop(bool, TraceGCTaskQueue, false, \
2414 "Trace actions of the GC task queues") \
2415 \
2416 diagnostic(bool, TraceGCTaskThread, false, \
2417 "Trace actions of the GC task threads") \
2418 \
2419 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2420 "Trace marking phase in ParallelOldGC") \
2421 \
2422 develop(bool, TraceParallelOldGCDensePrefix, false, \
2423 "Trace dense prefix computation for ParallelOldGC") \
2424 \
2425 develop(bool, IgnoreLibthreadGPFault, false, \
2426 "Suppress workaround for libthread GP fault") \
2427 \
2428 experimental(double, ObjectCountCutOffPercent, 0.5, \
2429 "The percentage of the used heap that the instances of a class " \
2430 "must occupy for the class to generate a trace event") \
2431 range(0.0, 100.0) \
2432 \
2433 /* JVMTI heap profiling */ \
2434 \
2435 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2436 "Trace JVMTI object tagging calls") \
2437 \
2438 diagnostic(bool, VerifyBeforeIteration, false, \
2439 "Verify memory system before JVMTI iteration") \
2440 \
2441 /* compiler interface */ \
2442 \
2443 develop(bool, CIPrintCompilerName, false, \
2444 "when CIPrint is active, print the name of the active compiler") \
2445 \
2446 diagnostic(bool, CIPrintCompileQueue, false, \
2447 "display the contents of the compile queue whenever a " \
2448 "compilation is enqueued") \
2449 \
2450 develop(bool, CIPrintRequests, false, \
2451 "display every request for compilation") \
2452 \
3334 product(uintx, TargetSurvivorRatio, 50, \
3335 "Desired percentage of survivor space used after scavenge") \
3336 range(0, 100) \
3337 \
3338 product(uintx, MarkSweepDeadRatio, 5, \
3339 "Percentage (0-100) of the old gen allowed as dead wood. " \
3340 "Serial mark sweep treats this as both the minimum and maximum " \
3341 "value. " \
3342 "CMS uses this value only if it falls back to mark sweep. " \
3343 "Par compact uses a variable scale based on the density of the " \
3344 "generation and treats this as the maximum value when the heap " \
3345 "is either completely full or completely empty. Par compact " \
3346 "also has a smaller default value; see arguments.cpp.") \
3347 range(0, 100) \
3348 \
3349 product(uintx, MarkSweepAlwaysCompactCount, 4, \
3350 "How often should we fully compact the heap (ignoring the dead " \
3351 "space parameters)") \
3352 range(1, max_uintx) \
3353 \
3354 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3355 "Delay between expansion and allocation (in milliseconds)") \
3356 \
3357 develop(uintx, GCWorkerDelayMillis, 0, \
3358 "Delay in scheduling GC workers (in milliseconds)") \
3359 \
3360 product(intx, DeferThrSuspendLoopCount, 4000, \
3361 "(Unstable) Number of times to iterate in safepoint loop " \
3362 "before blocking VM threads ") \
3363 range(-1, max_jint-1) \
3364 \
3365 product(intx, DeferPollingPageLoopCount, -1, \
3366 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3367 "before changing safepoint polling page to RO ") \
3368 range(-1, max_jint-1) \
3369 \
3370 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3371 range(0, max_intx) \
3372 \
3373 product(bool, PSChunkLargeArrays, true, \
4027 product(bool, DTraceAllocProbes, false, \
4028 "Enable dtrace probes for object allocation") \
4029 \
4030 product(bool, DTraceMonitorProbes, false, \
4031 "Enable dtrace probes for monitor events") \
4032 \
4033 product(bool, RelaxAccessControlCheck, false, \
4034 "Relax the access control checks in the verifier") \
4035 \
4036 product(uintx, StringTableSize, defaultStringTableSize, \
4037 "Number of buckets in the interned String table") \
4038 range(minimumStringTableSize, 111*defaultStringTableSize) \
4039 \
4040 experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
4041 "Number of buckets in the JVM internal Symbol table") \
4042 range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \
4043 \
4044 product(bool, UseStringDeduplication, false, \
4045 "Use string deduplication") \
4046 \
4047 product(uintx, StringDeduplicationAgeThreshold, 3, \
4048 "A string must reach this age (or be promoted to an old region) " \
4049 "to be considered for deduplication") \
4050 range(1, markOopDesc::max_age) \
4051 \
4052 diagnostic(bool, StringDeduplicationResizeALot, false, \
4053 "Force table resize every time the table is scanned") \
4054 \
4055 diagnostic(bool, StringDeduplicationRehashALot, false, \
4056 "Force table rehash every time the table is scanned") \
4057 \
4058 diagnostic(bool, WhiteBoxAPI, false, \
4059 "Enable internal testing APIs") \
4060 \
4061 experimental(intx, SurvivorAlignmentInBytes, 0, \
4062 "Default survivor space alignment in bytes") \
4063 constraint(SurvivorAlignmentInBytesConstraintFunc,AfterErgo) \
4064 \
4065 product(bool , AllowNonVirtualCalls, false, \
4066 "Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
4067 \
4068 product(ccstr, DumpLoadedClassList, NULL, \
4069 "Dump the names all loaded classes, that could be stored into " \
4070 "the CDS archive, in the specified file") \
4071 \
4072 product(ccstr, SharedClassListFile, NULL, \
4073 "Override the default CDS class list") \
4074 \
4075 diagnostic(ccstr, SharedArchiveFile, NULL, \
4076 "Override the default location of the CDS archive file") \
4077 \
4078 product(ccstr, ExtraSharedClassListFile, NULL, \
4079 "Extra classlist for building the CDS archive file") \
|