src/share/vm/runtime/globals.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/runtime

src/share/vm/runtime/globals.hpp

Print this page
rev 6362 : 8042298: Remove the names gen0 and gen1 from the GC code
Summary: Renamed gen0 and gen1 to young and old throughout the GC code.
Reviewed-by:


1441   product(uintx, ConcGCThreads, 0,                                          \
1442           "Number of threads concurrent gc will use")                       \
1443                                                                             \
1444   product(uintx, YoungPLABSize, 4096,                                       \
1445           "Size of young gen promotion LAB's (in HeapWords)")               \
1446                                                                             \
1447   product(uintx, OldPLABSize, 1024,                                         \
1448           "Size of old gen promotion LAB's (in HeapWords)")                 \
1449                                                                             \
1450   product(uintx, GCTaskTimeStampEntries, 200,                               \
1451           "Number of time stamp entries per gc worker thread")              \
1452                                                                             \
1453   product(bool, AlwaysTenure, false,                                        \
1454           "Always tenure objects in eden (ParallelGC only)")                \
1455                                                                             \
1456   product(bool, NeverTenure, false,                                         \
1457           "Never tenure objects in eden, may tenure on overflow "           \
1458           "(ParallelGC only)")                                              \
1459                                                                             \
1460   product(bool, ScavengeBeforeFullGC, true,                                 \
1461           "Scavenge youngest generation before each full GC, "              \
1462           "used with UseParallelGC")                                        \
1463                                                                             \
1464   develop(bool, ScavengeWithObjectsInToSpace, false,                        \
1465           "Allow scavenges to occur when to-space contains objects")        \
1466                                                                             \
1467   product(bool, UseConcMarkSweepGC, false,                                  \
1468           "Use Concurrent Mark-Sweep GC in the old generation")             \
1469                                                                             \
1470   product(bool, ExplicitGCInvokesConcurrent, false,                         \
1471           "A System.gc() request invokes a concurrent collection; "         \
1472           "(effective only when UseConcMarkSweepGC)")                       \
1473                                                                             \
1474   product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false,        \
1475           "A System.gc() request invokes a concurrent collection and "      \
1476           "also unloads classes during such a concurrent gc cycle "         \
1477           "(effective only when UseConcMarkSweepGC)")                       \
1478                                                                             \
1479   product(bool, GCLockerInvokesConcurrent, false,                           \
1480           "The exit of a JNI critical section necessitating a scavenge, "   \
1481           "also kicks off a background concurrent collection")              \
1482                                                                             \


2243                                                                             \
2244   diagnostic(bool, GCParallelVerificationEnabled, true,                     \
2245           "Enable parallel memory system verification")                     \
2246                                                                             \
2247   diagnostic(bool, DeferInitialCardMark, false,                             \
2248           "When +ReduceInitialCardMarks, explicitly defer any that "        \
2249           "may arise from new_pre_store_barrier")                           \
2250                                                                             \
2251   diagnostic(bool, VerifyRememberedSets, false,                             \
2252           "Verify GC remembered sets")                                      \
2253                                                                             \
2254   diagnostic(bool, VerifyObjectStartArray, true,                            \
2255           "Verify GC object start array if verify before/after")            \
2256                                                                             \
2257   product(bool, DisableExplicitGC, false,                                   \
2258           "Ignore calls to System.gc()")                                    \
2259                                                                             \
2260   notproduct(bool, CheckMemoryInitialization, false,                        \
2261           "Check memory initialization")                                    \
2262                                                                             \
2263   product(bool, CollectGen0First, false,                                    \
2264           "Collect youngest generation before each full GC")                \
2265                                                                             \
2266   diagnostic(bool, BindCMSThreadToCPU, false,                               \
2267           "Bind CMS Thread to CPU if possible")                             \
2268                                                                             \
2269   diagnostic(uintx, CPUForCMSThread, 0,                                     \
2270           "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2271                                                                             \
2272   product(bool, BindGCTaskThreadsToCPUs, false,                             \
2273           "Bind GCTaskThreads to CPUs if possible")                         \
2274                                                                             \
2275   product(bool, UseGCTaskAffinity, false,                                   \
2276           "Use worker affinity when asking for GCTasks")                    \
2277                                                                             \
2278   product(uintx, ProcessDistributionStride, 4,                              \
2279           "Stride through processors when distributing processes")          \
2280                                                                             \
2281   product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
2282           "Number of times the coordinator GC thread will sleep while "     \
2283           "yielding before giving up and resuming GC")                      \
2284                                                                             \
2285   product(uintx, CMSYieldSleepCount, 0,                                     \


2324                                                                             \
2325   product_rw(bool, TraceClassLoading, false,                                \
2326           "Trace all classes loaded")                                       \
2327                                                                             \
2328   product(bool, TraceClassLoadingPreorder, false,                           \
2329           "Trace all classes loaded in order referenced (not loaded)")      \
2330                                                                             \
2331   product_rw(bool, TraceClassUnloading, false,                              \
2332           "Trace unloading of classes")                                     \
2333                                                                             \
2334   product_rw(bool, TraceLoaderConstraints, false,                           \
2335           "Trace loader constraints")                                       \
2336                                                                             \
2337   develop(bool, TraceClassLoaderData, false,                                \
2338           "Trace class loader loader_data lifetime")                        \
2339                                                                             \
2340   product(uintx, InitialBootClassLoaderMetaspaceSize,                       \
2341           NOT_LP64(2200*K) LP64_ONLY(4*M),                                  \
2342           "Initial size of the boot class loader data metaspace")           \
2343                                                                             \
2344   product(bool, TraceGen0Time, false,                                       \
2345           "Trace accumulated time for Gen 0 collection")                    \
2346                                                                             \
2347   product(bool, TraceGen1Time, false,                                       \
2348           "Trace accumulated time for Gen 1 collection")                    \
2349                                                                             \
2350   product(bool, PrintTenuringDistribution, false,                           \
2351           "Print tenuring age information")                                 \
2352                                                                             \
2353   product_rw(bool, PrintHeapAtGC, false,                                    \
2354           "Print heap layout before and after each GC")                     \
2355                                                                             \
2356   product_rw(bool, PrintHeapAtGCExtended, false,                            \
2357           "Print extended information about the layout of the heap "        \
2358           "when -XX:+PrintHeapAtGC is set")                                 \
2359                                                                             \
2360   product(bool, PrintHeapAtSIGBREAK, true,                                  \
2361           "Print heap layout in response to SIGBREAK")                      \
2362                                                                             \
2363   manageable(bool, PrintClassHistogramBeforeFullGC, false,                  \
2364           "Print a class histogram before any major stop-world GC")         \
2365                                                                             \
2366   manageable(bool, PrintClassHistogramAfterFullGC, false,                   \
2367           "Print a class histogram after any major stop-world GC")          \
2368                                                                             \




1441   product(uintx, ConcGCThreads, 0,                                          \
1442           "Number of threads concurrent gc will use")                       \
1443                                                                             \
1444   product(uintx, YoungPLABSize, 4096,                                       \
1445           "Size of young gen promotion LAB's (in HeapWords)")               \
1446                                                                             \
1447   product(uintx, OldPLABSize, 1024,                                         \
1448           "Size of old gen promotion LAB's (in HeapWords)")                 \
1449                                                                             \
1450   product(uintx, GCTaskTimeStampEntries, 200,                               \
1451           "Number of time stamp entries per gc worker thread")              \
1452                                                                             \
1453   product(bool, AlwaysTenure, false,                                        \
1454           "Always tenure objects in eden (ParallelGC only)")                \
1455                                                                             \
1456   product(bool, NeverTenure, false,                                         \
1457           "Never tenure objects in eden, may tenure on overflow "           \
1458           "(ParallelGC only)")                                              \
1459                                                                             \
1460   product(bool, ScavengeBeforeFullGC, true,                                 \
1461           "Scavenge youngest generation before each full GC.")              \

1462                                                                             \
1463   develop(bool, ScavengeWithObjectsInToSpace, false,                        \
1464           "Allow scavenges to occur when to-space contains objects")        \
1465                                                                             \
1466   product(bool, UseConcMarkSweepGC, false,                                  \
1467           "Use Concurrent Mark-Sweep GC in the old generation")             \
1468                                                                             \
1469   product(bool, ExplicitGCInvokesConcurrent, false,                         \
1470           "A System.gc() request invokes a concurrent collection; "         \
1471           "(effective only when UseConcMarkSweepGC)")                       \
1472                                                                             \
1473   product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false,        \
1474           "A System.gc() request invokes a concurrent collection and "      \
1475           "also unloads classes during such a concurrent gc cycle "         \
1476           "(effective only when UseConcMarkSweepGC)")                       \
1477                                                                             \
1478   product(bool, GCLockerInvokesConcurrent, false,                           \
1479           "The exit of a JNI critical section necessitating a scavenge, "   \
1480           "also kicks off a background concurrent collection")              \
1481                                                                             \


2242                                                                             \
2243   diagnostic(bool, GCParallelVerificationEnabled, true,                     \
2244           "Enable parallel memory system verification")                     \
2245                                                                             \
2246   diagnostic(bool, DeferInitialCardMark, false,                             \
2247           "When +ReduceInitialCardMarks, explicitly defer any that "        \
2248           "may arise from new_pre_store_barrier")                           \
2249                                                                             \
2250   diagnostic(bool, VerifyRememberedSets, false,                             \
2251           "Verify GC remembered sets")                                      \
2252                                                                             \
2253   diagnostic(bool, VerifyObjectStartArray, true,                            \
2254           "Verify GC object start array if verify before/after")            \
2255                                                                             \
2256   product(bool, DisableExplicitGC, false,                                   \
2257           "Ignore calls to System.gc()")                                    \
2258                                                                             \
2259   notproduct(bool, CheckMemoryInitialization, false,                        \
2260           "Check memory initialization")                                    \
2261                                                                             \



2262   diagnostic(bool, BindCMSThreadToCPU, false,                               \
2263           "Bind CMS Thread to CPU if possible")                             \
2264                                                                             \
2265   diagnostic(uintx, CPUForCMSThread, 0,                                     \
2266           "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2267                                                                             \
2268   product(bool, BindGCTaskThreadsToCPUs, false,                             \
2269           "Bind GCTaskThreads to CPUs if possible")                         \
2270                                                                             \
2271   product(bool, UseGCTaskAffinity, false,                                   \
2272           "Use worker affinity when asking for GCTasks")                    \
2273                                                                             \
2274   product(uintx, ProcessDistributionStride, 4,                              \
2275           "Stride through processors when distributing processes")          \
2276                                                                             \
2277   product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
2278           "Number of times the coordinator GC thread will sleep while "     \
2279           "yielding before giving up and resuming GC")                      \
2280                                                                             \
2281   product(uintx, CMSYieldSleepCount, 0,                                     \


2320                                                                             \
2321   product_rw(bool, TraceClassLoading, false,                                \
2322           "Trace all classes loaded")                                       \
2323                                                                             \
2324   product(bool, TraceClassLoadingPreorder, false,                           \
2325           "Trace all classes loaded in order referenced (not loaded)")      \
2326                                                                             \
2327   product_rw(bool, TraceClassUnloading, false,                              \
2328           "Trace unloading of classes")                                     \
2329                                                                             \
2330   product_rw(bool, TraceLoaderConstraints, false,                           \
2331           "Trace loader constraints")                                       \
2332                                                                             \
2333   develop(bool, TraceClassLoaderData, false,                                \
2334           "Trace class loader loader_data lifetime")                        \
2335                                                                             \
2336   product(uintx, InitialBootClassLoaderMetaspaceSize,                       \
2337           NOT_LP64(2200*K) LP64_ONLY(4*M),                                  \
2338           "Initial size of the boot class loader data metaspace")           \
2339                                                                             \
2340   product(bool, TraceYoungGenTime, false,                                   \
2341           "Trace accumulated time for young collection")                    \
2342                                                                             \
2343   product(bool, TraceOldGenTime, false,                                     \
2344           "Trace accumulated time for old collection")                      \
2345                                                                             \
2346   product(bool, PrintTenuringDistribution, false,                           \
2347           "Print tenuring age information")                                 \
2348                                                                             \
2349   product_rw(bool, PrintHeapAtGC, false,                                    \
2350           "Print heap layout before and after each GC")                     \
2351                                                                             \
2352   product_rw(bool, PrintHeapAtGCExtended, false,                            \
2353           "Print extended information about the layout of the heap "        \
2354           "when -XX:+PrintHeapAtGC is set")                                 \
2355                                                                             \
2356   product(bool, PrintHeapAtSIGBREAK, true,                                  \
2357           "Print heap layout in response to SIGBREAK")                      \
2358                                                                             \
2359   manageable(bool, PrintClassHistogramBeforeFullGC, false,                  \
2360           "Print a class histogram before any major stop-world GC")         \
2361                                                                             \
2362   manageable(bool, PrintClassHistogramAfterFullGC, false,                   \
2363           "Print a class histogram after any major stop-world GC")          \
2364                                                                             \


src/share/vm/runtime/globals.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File