< prev index next >

src/share/vm/runtime/globals.hpp

Print this page




 966           "Print all malloc/free calls")                                    \
 967                                                                             \
 968   develop(bool, PrintMallocStatistics, false,                               \
 969           "Print malloc/free statistics")                                   \
 970                                                                             \
 971   develop(bool, ZapResourceArea, trueInDebug,                               \
 972           "Zap freed resource/arena space with 0xABABABAB")                 \
 973                                                                             \
 974   notproduct(bool, ZapVMHandleArea, trueInDebug,                            \
 975           "Zap freed VM handle space with 0xBCBCBCBC")                      \
 976                                                                             \
 977   develop(bool, ZapJNIHandleArea, trueInDebug,                              \
 978           "Zap freed JNI handle space with 0xFEFEFEFE")                     \
 979                                                                             \
 980   notproduct(bool, ZapStackSegments, trueInDebug,                           \
 981           "Zap allocated/freed stack segments with 0xFADFADED")             \
 982                                                                             \
 983   develop(bool, ZapUnusedHeapArea, trueInDebug,                             \
 984           "Zap unused heap space with 0xBAADBABE")                          \
 985                                                                             \
 986   develop(bool, TraceZapUnusedHeapArea, false,                              \
 987           "Trace zapping of unused heap space")                             \
 988                                                                             \
 989   develop(bool, CheckZapUnusedHeapArea, false,                              \
 990           "Check zapping of unused heap space")                             \
 991                                                                             \
 992   develop(bool, ZapFillerObjects, trueInDebug,                              \
 993           "Zap filler objects with 0xDEAFBABE")                             \
 994                                                                             \
 995   develop(bool, PrintVMMessages, true,                                      \
 996           "Print VM messages on console")                                   \
 997                                                                             \
 998   product(bool, PrintGCApplicationConcurrentTime, false,                    \
 999           "Print the time the application has been running")                \
1000                                                                             \
1001   product(bool, PrintGCApplicationStoppedTime, false,                       \
1002           "Print the time the application has been stopped")                \
1003                                                                             \
1004   diagnostic(bool, VerboseVerification, false,                              \
1005           "Display detailed verification details")                          \
1006                                                                             \
1007   notproduct(uintx, ErrorHandlerTest, 0,                                    \
1008           "If > 0, provokes an error after VM initialization; the value "   \
1009           "determines which error to provoke. See test_error_handler() "    \
1010           "in debug.cpp.")                                                  \
1011                                                                             \
1012   notproduct(uintx, TestCrashInErrorHandler, 0,                             \
1013           "If > 0, provokes an error inside VM error handler (a secondary " \
1014           "crash). see test_error_handler() in debug.cpp.")                 \
1015                                                                             \
1016   notproduct(bool, TestSafeFetchInErrorHandler, false,                      \
1017           "If true, tests SafeFetch inside error handler.")                 \
1018                                                                             \
1019   develop(bool, Verbose, false,                                             \
1020           "Print additional debugging information from other modes")        \
1021                                                                             \
1022   develop(bool, PrintMiscellaneous, false,                                  \
1023           "Print uncategorized debugging information (requires +Verbose)")  \


1569           "Number of parallel threads parallel gc will use")                \
1570           constraint(ParallelGCThreadsConstraintFunc,AfterErgo)             \
1571                                                                             \
1572   diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true,              \
1573             "Use semaphore synchronization for the GC Threads, "            \
1574             "instead of synchronization based on mutexes")                  \
1575                                                                             \
1576   product(bool, UseDynamicNumberOfGCThreads, false,                         \
1577           "Dynamically choose the number of parallel threads "              \
1578           "parallel gc will use")                                           \
1579                                                                             \
1580   diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
1581           "Force dynamic selection of the number of "                       \
1582           "parallel threads parallel gc will use to aid debugging")         \
1583                                                                             \
1584   product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M),              \
1585           "Size of heap (bytes) per GC thread used in calculating the "     \
1586           "number of GC threads")                                           \
1587           range((size_t)os::vm_page_size(), (size_t)max_uintx)              \
1588                                                                             \
1589   product(bool, TraceDynamicGCThreads, false,                               \
1590           "Trace the dynamic GC thread usage")                              \
1591                                                                             \
1592   product(uint, ConcGCThreads, 0,                                           \
1593           "Number of threads concurrent gc will use")                       \
1594           constraint(ConcGCThreadsConstraintFunc,AfterErgo)                 \
1595                                                                             \
1596   product(uintx, GCTaskTimeStampEntries, 200,                               \
1597           "Number of time stamp entries per gc worker thread")              \
1598           range(1, max_uintx)                                               \
1599                                                                             \
1600   product(bool, AlwaysTenure, false,                                        \
1601           "Always tenure objects in eden (ParallelGC only)")                \
1602                                                                             \
1603   product(bool, NeverTenure, false,                                         \
1604           "Never tenure objects in eden, may tenure on overflow "           \
1605           "(ParallelGC only)")                                              \
1606                                                                             \
1607   product(bool, ScavengeBeforeFullGC, true,                                 \
1608           "Scavenge youngest generation before each full GC.")              \
1609                                                                             \
1610   product(bool, UseConcMarkSweepGC, false,                                  \
1611           "Use Concurrent Mark-Sweep GC in the old generation")             \


1621                                                                             \
1622   product(bool, GCLockerInvokesConcurrent, false,                           \
1623           "The exit of a JNI critical section necessitating a scavenge, "   \
1624           "also kicks off a background concurrent collection")              \
1625                                                                             \
1626   product(uintx, GCLockerEdenExpansionPercent, 5,                           \
1627           "How much the GC can expand the eden by while the GC locker "     \
1628           "is active (as a percentage)")                                    \
1629           range(0, 100)                                                     \
1630                                                                             \
1631   diagnostic(uintx, GCLockerRetryAllocationCount, 2,                        \
1632           "Number of times to retry allocations when "                      \
1633           "blocked by the GC locker")                                       \
1634                                                                             \
1635   product(bool, UseCMSBestFit, true,                                        \
1636           "Use CMS best fit allocation strategy")                           \
1637                                                                             \
1638   product(bool, UseParNewGC, false,                                         \
1639           "Use parallel threads in the new generation")                     \
1640                                                                             \
1641   product(bool, PrintTaskqueue, false,                                      \
1642           "Print taskqueue statistics for parallel collectors")             \
1643                                                                             \
1644   product(bool, PrintTerminationStats, false,                               \
1645           "Print termination statistics for parallel collectors")           \
1646                                                                             \
1647   product(uintx, ParallelGCBufferWastePct, 10,                              \
1648           "Wasted fraction of parallel allocation buffer")                  \
1649           range(0, 100)                                                     \
1650                                                                             \
1651   product(uintx, TargetPLABWastePct, 10,                                    \
1652           "Target wasted space in last buffer as percent of overall "       \
1653           "allocation")                                                     \
1654           range(1, 100)                                                     \
1655                                                                             \
1656   product(uintx, PLABWeight, 75,                                            \
1657           "Percentage (0-100) used to weight the current sample when "      \
1658           "computing exponentially decaying average for ResizePLAB")        \
1659           range(0, 100)                                                     \
1660                                                                             \
1661   product(bool, ResizePLAB, true,                                           \
1662           "Dynamically resize (survivor space) promotion LAB's")            \
1663                                                                             \
1664   product(bool, PrintPLAB, false,                                           \
1665           "Print (survivor space) promotion LAB's sizing decisions")        \
1666                                                                             \


2141   develop(bool, TraceMetavirtualspaceAllocation, false,                     \
2142           "Trace virtual space metadata allocations")                       \
2143                                                                             \
2144   notproduct(bool, ExecuteInternalVMTests, false,                           \
2145           "Enable execution of internal VM tests")                          \
2146                                                                             \
2147   notproduct(bool, VerboseInternalVMTests, false,                           \
2148           "Turn on logging for internal VM tests.")                         \
2149                                                                             \
2150   product_pd(bool, UseTLAB, "Use thread-local object allocation")           \
2151                                                                             \
2152   product_pd(bool, ResizeTLAB,                                              \
2153           "Dynamically resize TLAB size for threads")                       \
2154                                                                             \
2155   product(bool, ZeroTLAB, false,                                            \
2156           "Zero out the newly created TLAB")                                \
2157                                                                             \
2158   product(bool, FastTLABRefill, true,                                       \
2159           "Use fast TLAB refill code")                                      \
2160                                                                             \
2161   product(bool, PrintTLAB, false,                                           \
2162           "Print various TLAB related information")                         \
2163                                                                             \
2164   product(bool, TLABStats, true,                                            \
2165           "Provide more detailed and expensive TLAB statistics "            \
2166           "(with PrintTLAB)")                                               \
2167                                                                             \
2168   product_pd(bool, NeverActAsServerClassMachine,                            \
2169           "Never act like a server-class machine")                          \
2170                                                                             \
2171   product(bool, AlwaysActAsServerClassMachine, false,                       \
2172           "Always act like a server-class machine")                         \
2173                                                                             \
2174   product_pd(uint64_t, MaxRAM,                                              \
2175           "Real memory size (in bytes) used to set maximum heap size")      \
2176           range(0, 0XFFFFFFFFFFFFFFFF)                                      \
2177                                                                             \
2178   product(size_t, ErgoHeapSizeLimit, 0,                                     \
2179           "Maximum ergonomically set heap size (in bytes); zero means use " \
2180           "MaxRAM / MaxRAMFraction")                                        \
2181                                                                             \
2182   product(uintx, MaxRAMFraction, 4,                                         \
2183           "Maximum fraction (1/n) of real memory used for maximum heap "    \
2184           "size")                                                           \
2185           range(1, max_uintx)                                               \
2186                                                                             \


2204           "Automatic GC selection pause threshold in milliseconds")         \
2205                                                                             \
2206   product(bool, UseAdaptiveSizePolicy, true,                                \
2207           "Use adaptive generation sizing policies")                        \
2208                                                                             \
2209   product(bool, UsePSAdaptiveSurvivorSizePolicy, true,                      \
2210           "Use adaptive survivor sizing policies")                          \
2211                                                                             \
2212   product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true,     \
2213           "Use adaptive young-old sizing policies at minor collections")    \
2214                                                                             \
2215   product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true,     \
2216           "Use adaptive young-old sizing policies at major collections")    \
2217                                                                             \
2218   product(bool, UseAdaptiveSizePolicyWithSystemGC, false,                   \
2219           "Include statistics from System.gc() for adaptive size policy")   \
2220                                                                             \
2221   product(bool, UseAdaptiveGCBoundary, false,                               \
2222           "Allow young-old boundary to move")                               \
2223                                                                             \
2224   develop(bool, TraceAdaptiveGCBoundary, false,                             \
2225           "Trace young-old boundary moves")                                 \
2226                                                                             \
2227   develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1,             \
2228           "Resize the virtual spaces of the young or old generations")      \
2229           range(-1, 1)                                                      \
2230                                                                             \
2231   product(uintx, AdaptiveSizeThroughPutPolicy, 0,                           \
2232           "Policy for changing generation size for throughput goals")       \
2233           range(0, 1)                                                       \
2234                                                                             \
2235   product(uintx, AdaptiveSizePolicyInitializingSteps, 20,                   \
2236           "Number of steps where heuristics is used before data is used")   \
2237                                                                             \
2238   develop(uintx, AdaptiveSizePolicyReadyThreshold, 5,                       \
2239           "Number of collections before the adaptive sizing is started")    \
2240                                                                             \
2241   product(uintx, AdaptiveSizePolicyOutputInterval, 0,                       \
2242           "Collection interval for printing information; zero means never") \
2243                                                                             \
2244   product(bool, UseAdaptiveSizePolicyFootprintGoal, true,                   \
2245           "Use adaptive minimum footprint as a goal")                       \
2246                                                                             \


2331           "Estimate of footprint other than Java Heap")                     \
2332                                                                             \
2333   product(bool, UseGCOverheadLimit, true,                                   \
2334           "Use policy to limit of proportion of time spent in GC "          \
2335           "before an OutOfMemory error is thrown")                          \
2336                                                                             \
2337   product(uintx, GCTimeLimit, 98,                                           \
2338           "Limit of the proportion of time spent in GC before "             \
2339           "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)")      \
2340           range(0, 100)                                                     \
2341                                                                             \
2342   product(uintx, GCHeapFreeLimit, 2,                                        \
2343           "Minimum percentage of free space after a full GC before an "     \
2344           "OutOfMemoryError is thrown (used with GCTimeLimit)")             \
2345           range(0, 100)                                                     \
2346                                                                             \
2347   develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5,                 \
2348           "Number of consecutive collections before gc time limit fires")   \
2349           range(1, max_uintx)                                               \
2350                                                                             \
2351   product(bool, PrintAdaptiveSizePolicy, false,                             \
2352           "Print information about AdaptiveSizePolicy")                     \
2353                                                                             \
2354   product(intx, PrefetchCopyIntervalInBytes, -1,                            \
2355           "How far ahead to prefetch destination area (<= 0 means off)")    \
2356                                                                             \
2357   product(intx, PrefetchScanIntervalInBytes, -1,                            \
2358           "How far ahead to prefetch scan area (<= 0 means off)")           \
2359                                                                             \
2360   product(intx, PrefetchFieldsAhead, -1,                                    \
2361           "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2362                                                                             \
2363   diagnostic(bool, VerifySilently, false,                                   \
2364           "Do not print the verification progress")                         \
2365                                                                             \
2366   diagnostic(bool, VerifyDuringStartup, false,                              \
2367           "Verify memory system before executing any Java code "            \
2368           "during VM initialization")                                       \
2369                                                                             \
2370   diagnostic(bool, VerifyBeforeExit, trueInDebug,                           \
2371           "Verify system before exiting")                                   \
2372                                                                             \
2373   diagnostic(bool, VerifyBeforeGC, false,                                   \
2374           "Verify memory system before GC")                                 \
2375                                                                             \
2376   diagnostic(bool, VerifyAfterGC, false,                                    \
2377           "Verify memory system after GC")                                  \
2378                                                                             \
2379   diagnostic(bool, VerifyDuringGC, false,                                   \
2380           "Verify memory system during GC (between phases)")                \
2381                                                                             \
2382   diagnostic(bool, GCParallelVerificationEnabled, true,                     \
2383           "Enable parallel memory system verification")                     \
2384                                                                             \
2385   diagnostic(bool, DeferInitialCardMark, false,                             \


2414           "Use worker affinity when asking for GCTasks")                    \
2415                                                                             \
2416   product(uintx, ProcessDistributionStride, 4,                              \
2417           "Stride through processors when distributing processes")          \
2418                                                                             \
2419   product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
2420           "Number of times the coordinator GC thread will sleep while "     \
2421           "yielding before giving up and resuming GC")                      \
2422                                                                             \
2423   product(uintx, CMSYieldSleepCount, 0,                                     \
2424           "Number of times a GC thread (minus the coordinator) "            \
2425           "will sleep while yielding before giving up and resuming GC")     \
2426                                                                             \
2427   /* gc tracing */                                                          \
2428   manageable(bool, PrintGC, false,                                          \
2429           "Print message at garbage collection")                            \
2430                                                                             \
2431   manageable(bool, PrintGCDetails, false,                                   \
2432           "Print more details at garbage collection")                       \
2433                                                                             \
2434   manageable(bool, PrintGCDateStamps, false,                                \
2435           "Print date stamps at garbage collection")                        \
2436                                                                             \
2437   manageable(bool, PrintGCTimeStamps, false,                                \
2438           "Print timestamps at garbage collection")                         \
2439                                                                             \
2440   manageable(bool, PrintGCID, true,                                         \
2441           "Print an identifier for each garbage collection")                \
2442                                                                             \
2443   product(bool, PrintGCTaskTimeStamps, false,                               \
2444           "Print timestamps for individual gc worker thread tasks")         \
2445                                                                             \
2446   develop(intx, ConcGCYieldTimeout, 0,                                      \
2447           "If non-zero, assert that GC threads yield within this "          \
2448           "number of milliseconds")                                         \
2449           range(0, max_intx)                                                \
2450                                                                             \
2451   product(bool, PrintReferenceGC, false,                                    \
2452           "Print times spent handling reference objects during GC "         \
2453           "(enabled only when PrintGCDetails)")                             \
2454                                                                             \
2455   develop(bool, TraceReferenceGC, false,                                    \
2456           "Trace handling of soft/weak/final/phantom references")           \
2457                                                                             \
2458   develop(bool, TraceFinalizerRegistration, false,                          \
2459           "Trace registration of final references")                         \
2460                                                                             \
2461   notproduct(bool, TraceScavenge, false,                                    \
2462           "Trace scavenge")                                                 \
2463                                                                             \
2464   product(bool, IgnoreEmptyClassPaths, false,                               \
2465           "Ignore empty path elements in -classpath")                       \
2466                                                                             \
2467   product(bool, TraceClassPaths, false,                                     \
2468           "Trace processing of class paths")                                \
2469                                                                             \
2470   product_rw(bool, TraceClassLoading, false,                                \
2471           "Trace all classes loaded")                                       \
2472                                                                             \
2473   product(bool, TraceClassLoadingPreorder, false,                           \
2474           "Trace all classes loaded in order referenced (not loaded)")      \
2475                                                                             \
2476   product_rw(bool, TraceClassUnloading, false,                              \
2477           "Trace unloading of classes")                                     \
2478                                                                             \
2479   product_rw(bool, TraceLoaderConstraints, false,                           \
2480           "Trace loader constraints")                                       \
2481                                                                             \
2482   develop(bool, TraceClassLoaderData, false,                                \
2483           "Trace class loader loader_data lifetime")                        \
2484                                                                             \
2485   product(size_t, InitialBootClassLoaderMetaspaceSize,                      \
2486           NOT_LP64(2200*K) LP64_ONLY(4*M),                                  \
2487           "Initial size of the boot class loader data metaspace")           \
2488           range(30*K, max_uintx/BytesPerWord)                               \
2489           constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2490                                                                             \
2491   product(bool, TraceYoungGenTime, false,                                   \
2492           "Trace accumulated time for young collection")                    \
2493                                                                             \
2494   product(bool, TraceOldGenTime, false,                                     \
2495           "Trace accumulated time for old collection")                      \
2496                                                                             \
2497   product(bool, PrintTenuringDistribution, false,                           \
2498           "Print tenuring age information")                                 \
2499                                                                             \
2500   product_rw(bool, PrintHeapAtGC, false,                                    \
2501           "Print heap layout before and after each GC")                     \
2502                                                                             \
2503   product_rw(bool, PrintHeapAtGCExtended, false,                            \
2504           "Print extended information about the layout of the heap "        \
2505           "when -XX:+PrintHeapAtGC is set")                                 \
2506                                                                             \
2507   product(bool, PrintHeapAtSIGBREAK, true,                                  \
2508           "Print heap layout in response to SIGBREAK")                      \
2509                                                                             \
2510   manageable(bool, PrintClassHistogramBeforeFullGC, false,                  \
2511           "Print a class histogram before any major stop-world GC")         \
2512                                                                             \
2513   manageable(bool, PrintClassHistogramAfterFullGC, false,                   \
2514           "Print a class histogram after any major stop-world GC")          \
2515                                                                             \
2516   manageable(bool, PrintClassHistogram, false,                              \
2517           "Print a histogram of class instances")                           \
2518                                                                             \
2519   develop(bool, TraceWorkGang, false,                                       \
2520           "Trace activities of work gangs")                                 \
2521                                                                             \
2522   product(bool, TraceParallelOldGCTasks, false,                             \
2523           "Trace multithreaded GC activity")                                \
2524                                                                             \
2525   develop(bool, TraceBlockOffsetTable, false,                               \
2526           "Print BlockOffsetTable maps")                                    \
2527                                                                             \
2528   develop(bool, TraceCardTableModRefBS, false,                              \
2529           "Print CardTableModRefBS maps")                                   \
2530                                                                             \
2531   develop(bool, TraceGCTaskManager, false,                                  \
2532           "Trace actions of the GC task manager")                           \
2533                                                                             \
2534   develop(bool, TraceGCTaskQueue, false,                                    \
2535           "Trace actions of the GC task queues")                            \
2536                                                                             \
2537   diagnostic(bool, TraceGCTaskThread, false,                                \
2538           "Trace actions of the GC task threads")                           \
2539                                                                             \
2540   product(bool, PrintParallelOldGCPhaseTimes, false,                        \
2541           "Print the time taken by each phase in ParallelOldGC "            \
2542           "(PrintGCDetails must also be enabled)")                          \
2543                                                                             \
2544   develop(bool, TraceParallelOldGCMarkingPhase, false,                      \
2545           "Trace marking phase in ParallelOldGC")                           \
2546                                                                             \
2547   develop(bool, TraceParallelOldGCSummaryPhase, false,                      \
2548           "Trace summary phase in ParallelOldGC")                           \
2549                                                                             \
2550   develop(bool, TraceParallelOldGCCompactionPhase, false,                   \
2551           "Trace compaction phase in ParallelOldGC")                        \
2552                                                                             \
2553   develop(bool, TraceParallelOldGCDensePrefix, false,                       \
2554           "Trace dense prefix computation for ParallelOldGC")               \
2555                                                                             \
2556   develop(bool, IgnoreLibthreadGPFault, false,                              \
2557           "Suppress workaround for libthread GP fault")                     \
2558                                                                             \
2559   product(bool, PrintJNIGCStalls, false,                                    \
2560           "Print diagnostic message when GC is stalled "                    \
2561           "by JNI critical section")                                        \
2562                                                                             \
2563   experimental(double, ObjectCountCutOffPercent, 0.5,                       \
2564           "The percentage of the used heap that the instances of a class "  \
2565           "must occupy for the class to generate a trace event")            \
2566           range(0.0, 100.0)                                                 \
2567                                                                             \
2568   /* GC log rotation setting */                                             \
2569                                                                             \
2570   product(bool, UseGCLogFileRotation, false,                                \
2571           "Rotate gclog files (for long running applications). It requires "\




 966           "Print all malloc/free calls")                                    \
 967                                                                             \
 968   develop(bool, PrintMallocStatistics, false,                               \
 969           "Print malloc/free statistics")                                   \
 970                                                                             \
 971   develop(bool, ZapResourceArea, trueInDebug,                               \
 972           "Zap freed resource/arena space with 0xABABABAB")                 \
 973                                                                             \
 974   notproduct(bool, ZapVMHandleArea, trueInDebug,                            \
 975           "Zap freed VM handle space with 0xBCBCBCBC")                      \
 976                                                                             \
 977   develop(bool, ZapJNIHandleArea, trueInDebug,                              \
 978           "Zap freed JNI handle space with 0xFEFEFEFE")                     \
 979                                                                             \
 980   notproduct(bool, ZapStackSegments, trueInDebug,                           \
 981           "Zap allocated/freed stack segments with 0xFADFADED")             \
 982                                                                             \
 983   develop(bool, ZapUnusedHeapArea, trueInDebug,                             \
 984           "Zap unused heap space with 0xBAADBABE")                          \
 985                                                                             \



 986   develop(bool, CheckZapUnusedHeapArea, false,                              \
 987           "Check zapping of unused heap space")                             \
 988                                                                             \
 989   develop(bool, ZapFillerObjects, trueInDebug,                              \
 990           "Zap filler objects with 0xDEAFBABE")                             \
 991                                                                             \
 992   develop(bool, PrintVMMessages, true,                                      \
 993           "Print VM messages on console")                                   \
 994                                                                             \






 995   diagnostic(bool, VerboseVerification, false,                              \
 996           "Display detailed verification details")                          \
 997                                                                             \
 998   notproduct(uintx, ErrorHandlerTest, 0,                                    \
 999           "If > 0, provokes an error after VM initialization; the value "   \
1000           "determines which error to provoke. See test_error_handler() "    \
1001           "in debug.cpp.")                                                  \
1002                                                                             \
1003   notproduct(uintx, TestCrashInErrorHandler, 0,                             \
1004           "If > 0, provokes an error inside VM error handler (a secondary " \
1005           "crash). see test_error_handler() in debug.cpp.")                 \
1006                                                                             \
1007   notproduct(bool, TestSafeFetchInErrorHandler, false,                      \
1008           "If true, tests SafeFetch inside error handler.")                 \
1009                                                                             \
1010   develop(bool, Verbose, false,                                             \
1011           "Print additional debugging information from other modes")        \
1012                                                                             \
1013   develop(bool, PrintMiscellaneous, false,                                  \
1014           "Print uncategorized debugging information (requires +Verbose)")  \


1560           "Number of parallel threads parallel gc will use")                \
1561           constraint(ParallelGCThreadsConstraintFunc,AfterErgo)             \
1562                                                                             \
1563   diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true,              \
1564             "Use semaphore synchronization for the GC Threads, "            \
1565             "instead of synchronization based on mutexes")                  \
1566                                                                             \
1567   product(bool, UseDynamicNumberOfGCThreads, false,                         \
1568           "Dynamically choose the number of parallel threads "              \
1569           "parallel gc will use")                                           \
1570                                                                             \
1571   diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
1572           "Force dynamic selection of the number of "                       \
1573           "parallel threads parallel gc will use to aid debugging")         \
1574                                                                             \
1575   product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M),              \
1576           "Size of heap (bytes) per GC thread used in calculating the "     \
1577           "number of GC threads")                                           \
1578           range((size_t)os::vm_page_size(), (size_t)max_uintx)              \
1579                                                                             \



1580   product(uint, ConcGCThreads, 0,                                           \
1581           "Number of threads concurrent gc will use")                       \
1582           constraint(ConcGCThreadsConstraintFunc,AfterErgo)                 \
1583                                                                             \
1584   product(uintx, GCTaskTimeStampEntries, 200,                               \
1585           "Number of time stamp entries per gc worker thread")              \
1586           range(1, max_uintx)                                               \
1587                                                                             \
1588   product(bool, AlwaysTenure, false,                                        \
1589           "Always tenure objects in eden (ParallelGC only)")                \
1590                                                                             \
1591   product(bool, NeverTenure, false,                                         \
1592           "Never tenure objects in eden, may tenure on overflow "           \
1593           "(ParallelGC only)")                                              \
1594                                                                             \
1595   product(bool, ScavengeBeforeFullGC, true,                                 \
1596           "Scavenge youngest generation before each full GC.")              \
1597                                                                             \
1598   product(bool, UseConcMarkSweepGC, false,                                  \
1599           "Use Concurrent Mark-Sweep GC in the old generation")             \


1609                                                                             \
1610   product(bool, GCLockerInvokesConcurrent, false,                           \
1611           "The exit of a JNI critical section necessitating a scavenge, "   \
1612           "also kicks off a background concurrent collection")              \
1613                                                                             \
1614   product(uintx, GCLockerEdenExpansionPercent, 5,                           \
1615           "How much the GC can expand the eden by while the GC locker "     \
1616           "is active (as a percentage)")                                    \
1617           range(0, 100)                                                     \
1618                                                                             \
1619   diagnostic(uintx, GCLockerRetryAllocationCount, 2,                        \
1620           "Number of times to retry allocations when "                      \
1621           "blocked by the GC locker")                                       \
1622                                                                             \
1623   product(bool, UseCMSBestFit, true,                                        \
1624           "Use CMS best fit allocation strategy")                           \
1625                                                                             \
1626   product(bool, UseParNewGC, false,                                         \
1627           "Use parallel threads in the new generation")                     \
1628                                                                             \






1629   product(uintx, ParallelGCBufferWastePct, 10,                              \
1630           "Wasted fraction of parallel allocation buffer")                  \
1631           range(0, 100)                                                     \
1632                                                                             \
1633   product(uintx, TargetPLABWastePct, 10,                                    \
1634           "Target wasted space in last buffer as percent of overall "       \
1635           "allocation")                                                     \
1636           range(1, 100)                                                     \
1637                                                                             \
1638   product(uintx, PLABWeight, 75,                                            \
1639           "Percentage (0-100) used to weight the current sample when "      \
1640           "computing exponentially decaying average for ResizePLAB")        \
1641           range(0, 100)                                                     \
1642                                                                             \
1643   product(bool, ResizePLAB, true,                                           \
1644           "Dynamically resize (survivor space) promotion LAB's")            \
1645                                                                             \
1646   product(bool, PrintPLAB, false,                                           \
1647           "Print (survivor space) promotion LAB's sizing decisions")        \
1648                                                                             \


2123   develop(bool, TraceMetavirtualspaceAllocation, false,                     \
2124           "Trace virtual space metadata allocations")                       \
2125                                                                             \
2126   notproduct(bool, ExecuteInternalVMTests, false,                           \
2127           "Enable execution of internal VM tests")                          \
2128                                                                             \
2129   notproduct(bool, VerboseInternalVMTests, false,                           \
2130           "Turn on logging for internal VM tests.")                         \
2131                                                                             \
2132   product_pd(bool, UseTLAB, "Use thread-local object allocation")           \
2133                                                                             \
2134   product_pd(bool, ResizeTLAB,                                              \
2135           "Dynamically resize TLAB size for threads")                       \
2136                                                                             \
2137   product(bool, ZeroTLAB, false,                                            \
2138           "Zero out the newly created TLAB")                                \
2139                                                                             \
2140   product(bool, FastTLABRefill, true,                                       \
2141           "Use fast TLAB refill code")                                      \
2142                                                                             \



2143   product(bool, TLABStats, true,                                            \
2144           "Provide more detailed and expensive TLAB statistics.")           \

2145                                                                             \
2146   product_pd(bool, NeverActAsServerClassMachine,                            \
2147           "Never act like a server-class machine")                          \
2148                                                                             \
2149   product(bool, AlwaysActAsServerClassMachine, false,                       \
2150           "Always act like a server-class machine")                         \
2151                                                                             \
2152   product_pd(uint64_t, MaxRAM,                                              \
2153           "Real memory size (in bytes) used to set maximum heap size")      \
2154           range(0, 0XFFFFFFFFFFFFFFFF)                                      \
2155                                                                             \
2156   product(size_t, ErgoHeapSizeLimit, 0,                                     \
2157           "Maximum ergonomically set heap size (in bytes); zero means use " \
2158           "MaxRAM / MaxRAMFraction")                                        \
2159                                                                             \
2160   product(uintx, MaxRAMFraction, 4,                                         \
2161           "Maximum fraction (1/n) of real memory used for maximum heap "    \
2162           "size")                                                           \
2163           range(1, max_uintx)                                               \
2164                                                                             \


2182           "Automatic GC selection pause threshold in milliseconds")         \
2183                                                                             \
2184   product(bool, UseAdaptiveSizePolicy, true,                                \
2185           "Use adaptive generation sizing policies")                        \
2186                                                                             \
2187   product(bool, UsePSAdaptiveSurvivorSizePolicy, true,                      \
2188           "Use adaptive survivor sizing policies")                          \
2189                                                                             \
2190   product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true,     \
2191           "Use adaptive young-old sizing policies at minor collections")    \
2192                                                                             \
2193   product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true,     \
2194           "Use adaptive young-old sizing policies at major collections")    \
2195                                                                             \
2196   product(bool, UseAdaptiveSizePolicyWithSystemGC, false,                   \
2197           "Include statistics from System.gc() for adaptive size policy")   \
2198                                                                             \
2199   product(bool, UseAdaptiveGCBoundary, false,                               \
2200           "Allow young-old boundary to move")                               \
2201                                                                             \



2202   develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1,             \
2203           "Resize the virtual spaces of the young or old generations")      \
2204           range(-1, 1)                                                      \
2205                                                                             \
2206   product(uintx, AdaptiveSizeThroughPutPolicy, 0,                           \
2207           "Policy for changing generation size for throughput goals")       \
2208           range(0, 1)                                                       \
2209                                                                             \
2210   product(uintx, AdaptiveSizePolicyInitializingSteps, 20,                   \
2211           "Number of steps where heuristics is used before data is used")   \
2212                                                                             \
2213   develop(uintx, AdaptiveSizePolicyReadyThreshold, 5,                       \
2214           "Number of collections before the adaptive sizing is started")    \
2215                                                                             \
2216   product(uintx, AdaptiveSizePolicyOutputInterval, 0,                       \
2217           "Collection interval for printing information; zero means never") \
2218                                                                             \
2219   product(bool, UseAdaptiveSizePolicyFootprintGoal, true,                   \
2220           "Use adaptive minimum footprint as a goal")                       \
2221                                                                             \


2306           "Estimate of footprint other than Java Heap")                     \
2307                                                                             \
2308   product(bool, UseGCOverheadLimit, true,                                   \
2309           "Use policy to limit of proportion of time spent in GC "          \
2310           "before an OutOfMemory error is thrown")                          \
2311                                                                             \
2312   product(uintx, GCTimeLimit, 98,                                           \
2313           "Limit of the proportion of time spent in GC before "             \
2314           "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)")      \
2315           range(0, 100)                                                     \
2316                                                                             \
2317   product(uintx, GCHeapFreeLimit, 2,                                        \
2318           "Minimum percentage of free space after a full GC before an "     \
2319           "OutOfMemoryError is thrown (used with GCTimeLimit)")             \
2320           range(0, 100)                                                     \
2321                                                                             \
2322   develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5,                 \
2323           "Number of consecutive collections before gc time limit fires")   \
2324           range(1, max_uintx)                                               \
2325                                                                             \



2326   product(intx, PrefetchCopyIntervalInBytes, -1,                            \
2327           "How far ahead to prefetch destination area (<= 0 means off)")    \
2328                                                                             \
2329   product(intx, PrefetchScanIntervalInBytes, -1,                            \
2330           "How far ahead to prefetch scan area (<= 0 means off)")           \
2331                                                                             \
2332   product(intx, PrefetchFieldsAhead, -1,                                    \
2333           "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2334                                                                             \



2335   diagnostic(bool, VerifyDuringStartup, false,                              \
2336           "Verify memory system before executing any Java code "            \
2337           "during VM initialization")                                       \
2338                                                                             \
2339   diagnostic(bool, VerifyBeforeExit, trueInDebug,                           \
2340           "Verify system before exiting")                                   \
2341                                                                             \
2342   diagnostic(bool, VerifyBeforeGC, false,                                   \
2343           "Verify memory system before GC")                                 \
2344                                                                             \
2345   diagnostic(bool, VerifyAfterGC, false,                                    \
2346           "Verify memory system after GC")                                  \
2347                                                                             \
2348   diagnostic(bool, VerifyDuringGC, false,                                   \
2349           "Verify memory system during GC (between phases)")                \
2350                                                                             \
2351   diagnostic(bool, GCParallelVerificationEnabled, true,                     \
2352           "Enable parallel memory system verification")                     \
2353                                                                             \
2354   diagnostic(bool, DeferInitialCardMark, false,                             \


2383           "Use worker affinity when asking for GCTasks")                    \
2384                                                                             \
2385   product(uintx, ProcessDistributionStride, 4,                              \
2386           "Stride through processors when distributing processes")          \
2387                                                                             \
2388   product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
2389           "Number of times the coordinator GC thread will sleep while "     \
2390           "yielding before giving up and resuming GC")                      \
2391                                                                             \
2392   product(uintx, CMSYieldSleepCount, 0,                                     \
2393           "Number of times a GC thread (minus the coordinator) "            \
2394           "will sleep while yielding before giving up and resuming GC")     \
2395                                                                             \
2396   /* gc tracing */                                                          \
2397   manageable(bool, PrintGC, false,                                          \
2398           "Print message at garbage collection")                            \
2399                                                                             \
2400   manageable(bool, PrintGCDetails, false,                                   \
2401           "Print more details at garbage collection")                       \
2402                                                                             \



2403   manageable(bool, PrintGCTimeStamps, false,                                \
2404           "Print timestamps at garbage collection")                         \
2405                                                                             \






2406   develop(intx, ConcGCYieldTimeout, 0,                                      \
2407           "If non-zero, assert that GC threads yield within this "          \
2408           "number of milliseconds")                                         \
2409           range(0, max_intx)                                                \
2410                                                                             \
2411   product(bool, PrintReferenceGC, false,                                    \
2412           "Print times spent handling reference objects during GC "         \
2413           "(enabled only when PrintGCDetails)")                             \
2414                                                                             \



2415   develop(bool, TraceFinalizerRegistration, false,                          \
2416           "Trace registration of final references")                         \
2417                                                                             \
2418   notproduct(bool, TraceScavenge, false,                                    \
2419           "Trace scavenge")                                                 \
2420                                                                             \
2421   product(bool, IgnoreEmptyClassPaths, false,                               \
2422           "Ignore empty path elements in -classpath")                       \
2423                                                                             \
2424   product(bool, TraceClassPaths, false,                                     \
2425           "Trace processing of class paths")                                \
2426                                                                             \
2427   product_rw(bool, TraceClassLoading, false,                                \
2428           "Trace all classes loaded")                                       \
2429                                                                             \
2430   product(bool, TraceClassLoadingPreorder, false,                           \
2431           "Trace all classes loaded in order referenced (not loaded)")      \
2432                                                                             \
2433   product_rw(bool, TraceClassUnloading, false,                              \
2434           "Trace unloading of classes")                                     \
2435                                                                             \
2436   product_rw(bool, TraceLoaderConstraints, false,                           \
2437           "Trace loader constraints")                                       \
2438                                                                             \
2439   develop(bool, TraceClassLoaderData, false,                                \
2440           "Trace class loader loader_data lifetime")                        \
2441                                                                             \
2442   product(size_t, InitialBootClassLoaderMetaspaceSize,                      \
2443           NOT_LP64(2200*K) LP64_ONLY(4*M),                                  \
2444           "Initial size of the boot class loader data metaspace")           \
2445           range(30*K, max_uintx/BytesPerWord)                               \
2446           constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
2447                                                                             \
2448   product(bool, TraceYoungGenTime, false,                                   \
2449           "Trace accumulated time for young collection")                    \
2450                                                                             \
2451   product(bool, TraceOldGenTime, false,                                     \
2452           "Trace accumulated time for old collection")                      \
2453                                                                             \










2454   product(bool, PrintHeapAtSIGBREAK, true,                                  \
2455           "Print heap layout in response to SIGBREAK")                      \
2456                                                                             \



2457   manageable(bool, PrintClassHistogramAfterFullGC, false,                   \
2458           "Print a class histogram after any major stop-world GC")          \
2459                                                                             \
2460   manageable(bool, PrintClassHistogram, false,                              \
2461           "Print a histogram of class instances")                           \
2462                                                                             \
2463   develop(bool, TraceWorkGang, false,                                       \
2464           "Trace activities of work gangs")                                 \
2465                                                                             \
2466   product(bool, TraceParallelOldGCTasks, false,                             \
2467           "Trace multithreaded GC activity")                                \
2468                                                                             \






2469   develop(bool, TraceGCTaskManager, false,                                  \
2470           "Trace actions of the GC task manager")                           \
2471                                                                             \
2472   develop(bool, TraceGCTaskQueue, false,                                    \
2473           "Trace actions of the GC task queues")                            \
2474                                                                             \
2475   diagnostic(bool, TraceGCTaskThread, false,                                \
2476           "Trace actions of the GC task threads")                           \
2477                                                                             \
2478   product(bool, PrintParallelOldGCPhaseTimes, false,                        \
2479           "Print the time taken by each phase in ParallelOldGC "            \
2480           "(PrintGCDetails must also be enabled)")                          \
2481                                                                             \
2482   develop(bool, TraceParallelOldGCMarkingPhase, false,                      \
2483           "Trace marking phase in ParallelOldGC")                           \






2484                                                                             \
2485   develop(bool, TraceParallelOldGCDensePrefix, false,                       \
2486           "Trace dense prefix computation for ParallelOldGC")               \
2487                                                                             \
2488   develop(bool, IgnoreLibthreadGPFault, false,                              \
2489           "Suppress workaround for libthread GP fault")                     \
2490                                                                             \
2491   product(bool, PrintJNIGCStalls, false,                                    \
2492           "Print diagnostic message when GC is stalled "                    \
2493           "by JNI critical section")                                        \
2494                                                                             \
2495   experimental(double, ObjectCountCutOffPercent, 0.5,                       \
2496           "The percentage of the used heap that the instances of a class "  \
2497           "must occupy for the class to generate a trace event")            \
2498           range(0.0, 100.0)                                                 \
2499                                                                             \
2500   /* GC log rotation setting */                                             \
2501                                                                             \
2502   product(bool, UseGCLogFileRotation, false,                                \
2503           "Rotate gclog files (for long running applications). It requires "\


< prev index next >