graal-compiler: src/share/vm/runtime/globals.hpp comparison

comparison src/share/vm/runtime/globals.hpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	b2934877ba61 f2110083203d
children	36bcc10e01c0

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }
 ~CounterSetting()         { (*counter)--; }
 };
-class IntFlagSetting {
+class UIntFlagSetting {
-intx val;
+uintx val;
-intx* flag;
+uintx* flag;
 public:
-IntFlagSetting(intx& fl, intx newValue) { flag = &fl; val = fl; fl = newValue; }
+UIntFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }
-~IntFlagSetting()                       { *flag = val; }
+~UIntFlagSetting()                         { *flag = val; }
 };
 class DoubleFlagSetting {
 double val;
 "Granularity to use for NUMA interleaving on Windows OS")         \
 \
 product(bool, ForceNUMA, false,                                           \
 "Force NUMA optimizations on single-node/UMA systems")            \
 \
-product(intx, NUMAChunkResizeWeight, 20,                                  \
+product(uintx, NUMAChunkResizeWeight, 20,                                 \
-"Percentage (0-100) used to weight the current sample when "      \
+"Percentage (0-100) used to weigh the current sample when "      \
 "computing exponentially decaying average for "                   \
 "AdaptiveNUMAChunkSizing")                                        \
 \
-product(intx, NUMASpaceResizeRate, 1*G,                                   \
+product(uintx, NUMASpaceResizeRate, 1*G,                                  \
 "Do not reallocate more that this amount per collection")         \
 \
 product(bool, UseAdaptiveNUMAChunkSizing, true,                           \
 "Enable adaptive chunk sizing for NUMA")                          \
 \
 product(bool, NUMAStats, false,                                           \
 "Print NUMA stats in detailed heap information")                  \
 \
-product(intx, NUMAPageScanRate, 256,                                      \
+product(uintx, NUMAPageScanRate, 256,                                     \
 "Maximum number of pages to include in the page scan procedure")  \
 \
 product_pd(bool, NeedsDeoptSuspend,                                       \
 "True for register window machines (sparc/ia64)")                 \
 \
 "Bump the number of file descriptors to max in solaris.")         \
 \
 diagnostic(bool, LogEvents, true,                                         \
 "Enable the various ring buffer event logs")                   \
 \
-diagnostic(intx, LogEventsBufferEntries, 10,                              \
+diagnostic(uintx, LogEventsBufferEntries, 10,                             \
 "Enable the various ring buffer event logs")                   \
 \
 product(bool, BytecodeVerificationRemote, true,                           \
 "Enables the Java bytecode verifier for remote classes")          \
 \
 "0 - type based with oops first, 1 - with oops last, "            \
 "2 - oops in super and sub classes are together")                 \
 \
 product(bool, CompactFields, true,                                        \
 "Allocate nonstatic fields in gaps between previous fields")      \
-\
-notproduct(bool, PrintCompactFieldsSavings, false,                        \
-"Print how many words were saved with CompactFields")             \
 \
 notproduct(bool, PrintFieldLayout, false,                                 \
 "Print field layout for each class")                              \
 \
 product(intx, ContendedPaddingWidth, 128,                                 \
 "Use parallel threads in the new generation.")                    \
 \
 product(bool, ParallelGCVerbose, false,                                   \
 "Verbose output for parallel GC.")                                \
 \
-product(intx, ParallelGCBufferWastePct, 10,                               \
+product(uintx, ParallelGCBufferWastePct, 10,                              \
-"wasted fraction of parallel allocation buffer.")                 \
+"Wasted fraction of parallel allocation buffer.")                 \
 \
 diagnostic(bool, ParallelGCRetainPLAB, false,                             \
 "Retain parallel allocation buffers across scavenges; "        \
 " -- disabled because this currently conflicts with "          \
 " parallel card scanning under certain conditions ")           \
 \
-product(intx, TargetPLABWastePct, 10,                                     \
+product(uintx, TargetPLABWastePct, 10,                                    \
-"target wasted space in last buffer as pct of overall allocation")\
+"Target wasted space in last buffer as percent of overall "       \
+"allocation")                                                     \
 \
 product(uintx, PLABWeight, 75,                                            \
 "Percentage (0-100) used to weight the current sample when"       \
 "computing exponentially decaying average for ResizePLAB.")       \
 \
 " during a scavenge")                                             \
 \
 product(bool, AlwaysPreTouch, false,                                      \
 "It forces all freshly committed pages to be pre-touched.")       \
 \
-product_pd(intx, CMSYoungGenPerWorker,                                    \
+product_pd(uintx, CMSYoungGenPerWorker,                                   \
 "The maximum size of young gen chosen by default per GC worker "  \
 "thread available")                                               \
 \
 product(bool, CMSIncrementalMode, false,                                  \
 "Whether CMS GC should operate in \"incremental\" mode")          \
 "denotes 'do constant GC cycles'.")                               \
 \
 product(bool, UseCMSInitiatingOccupancyOnly, false,                       \
 "Only use occupancy as a crierion for starting a CMS collection") \
 \
-product(intx, CMSIsTooFullPercentage, 98,                                 \
+product(uintx, CMSIsTooFullPercentage, 98,                                \
 "An absolute ceiling above which CMS will always consider the "   \
 "unloading of classes when class unloading is enabled")           \
 \
 develop(bool, CMSTestInFreeList, false,                                   \
 "Check if the coalesced range is already in the "                 \
 "(other young collectors) ")                                      \
 \
 develop(uintx, PromotionFailureALotInterval, 5,                           \
 "Total collections between promotion failures alot")              \
 \
-experimental(intx, WorkStealingSleepMillis, 1,                            \
+experimental(uintx, WorkStealingSleepMillis, 1,                           \
 "Sleep time when sleep is used for yields")                       \
 \
 experimental(uintx, WorkStealingYieldsBeforeSleep, 5000,                  \
 "Number of yields before a sleep is done during workstealing")    \
 \
 \
 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5,                       \
 "Number of collections before the adaptive sizing is started")    \
 \
 product(uintx, AdaptiveSizePolicyOutputInterval, 0,                       \
-"Collecton interval for printing information; zero => never")     \
+"Collection interval for printing information; zero means never") \
 \
 product(bool, UseAdaptiveSizePolicyFootprintGoal, true,                   \
 "Use adaptive minimum footprint as a goal")                       \
 \
 product(uintx, AdaptiveSizePolicyWeight, 10,                              \
 "How far ahead to prefetch scan area (<= 0 means off)")           \
 \
 product(intx, PrefetchFieldsAhead, -1,                                    \
 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
 \
+diagnostic(bool, VerifySilently, false,                                   \
+"Don't print print the verification progress")                    \
+\
 diagnostic(bool, VerifyDuringStartup, false,                              \
 "Verify memory system before executing any Java code "            \
 "during VM initialization")                                       \
 \
 diagnostic(bool, VerifyBeforeExit, trueInDebug,                           \
 "Suppress workaround for libthread GP fault")                     \
 \
 product(bool, PrintJNIGCStalls, false,                                    \
 "Print diagnostic message when GC is stalled"                     \
 "by JNI critical section")                                        \
+\
+experimental(double, ObjectCountCutOffPercent, 0.5,                       \
+"The percentage of the used heap that the instances of a class "  \
+"must occupy for the class to generate a trace event.")           \
 \
 /* GC log rotation setting */                                             \
 \
 product(bool, UseGCLogFileRotation, false,                                \
 "Prevent large gclog file for long running app. "                 \
 product_pd(intx, PreInflateSpin,                                          \
 "Number of times to spin wait before inflation")                  \
 \
 /* gc parameters */                                                       \
 product(uintx, InitialHeapSize, 0,                                        \
-"Initial heap size (in bytes); zero means OldSize + NewSize")     \
+"Initial heap size (in bytes); zero means use ergonomics")        \
 \
 product(uintx, MaxHeapSize, ScaleForWordSize(96*M),                       \
 "Maximum heap size (in bytes)")                                   \
 \
 product(uintx, OldSize, ScaleForWordSize(4*M),                            \
 "Max percentage of Metaspace free after GC to avoid shrinking")   \
 \
 product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M),              \
 "Max expansion of Metaspace without full GC (in bytes)")          \
 \
-product(intx, QueuedAllocationWarningCount, 0,                            \
+product(uintx, QueuedAllocationWarningCount, 0,                           \
 "Number of times an allocation that queues behind a GC "          \
 "will retry before printing a warning")                           \
 \
 diagnostic(uintx, VerifyGCStartAt,   0,                                   \
 "GC invoke count where +VerifyBefore/AfterGC kicks in")           \
 "Par compact uses a variable scale based on the density of the"   \
 "generation and treats this as the max value when the heap is"    \
 "either completely full or completely empty.  Par compact also"   \
 "has a smaller default value; see arguments.cpp.")                \
 \
-product(intx, MarkSweepAlwaysCompactCount,     4,                         \
+product(uintx, MarkSweepAlwaysCompactCount,     4,                        \
 "How often should we fully compact the heap (ignoring the dead "  \
 "space parameters)")                                              \
 \
 product(intx, PrintCMSStatistics, 0,                                      \
 "Statistics for CMS")                                             \
 "Min number of seconds between code cache cleaning sessions")     \
 \
 product(uintx,  CodeCacheFlushingMinimumFreeSpace, 1500*K,                \
 "When less than X space left, start code cache cleaning")         \
 \
+product(uintx, CodeCacheFlushingFraction, 2,                              \
+"Fraction of the code cache that is flushed when full")           \
+\
 /* interpreter debugging */                                               \
 develop(intx, BinarySwitchThreshold, 5,                                   \
 "Minimal number of lookupswitch entries for rewriting to binary " \
 "switch")                                                         \
 \
 "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \
 \
 develop(bool, ReplayCompiles, false,                                      \
 "Enable replay of compilations from ReplayDataFile")              \
 \
-develop(ccstr, ReplayDataFile, "replay.txt",                              \
+product(ccstr, ReplayDataFile, NULL,                                      \
-"file containing compilation replay information")                 \
+"File containing compilation replay information"                  \
+"[default: ./replay_pid%p.log] (%p replaced with pid)")           \
 \
 develop(intx, ReplaySuppressInitializers, 2,                              \
 "Controls handling of class initialization during replay"         \
 "0 - don't do anything special"                                   \
 "1 - treat all class initializers as empty"                       \
 "    pretend they are empty after starting replay")               \
 \
 develop(bool, ReplayIgnoreInitErrors, false,                              \
 "Ignore exceptions thrown during initialization for replay")      \
 \
-develop(bool, DumpReplayDataOnError, true,                                \
+product(bool, DumpReplayDataOnError, true,                                \
-"record replay data for crashing compiler threads")               \
+"Record replay data for crashing compiler threads")               \
 \
 product(bool, CICompilerCountPerCPU, false,                               \
 "1 compiler thread for log(N CPUs)")                              \
 \
 develop(intx, CIFireOOMAt,    -1,                                         \
 "Fire OutOfMemoryErrors throughout CI for testing the compiler "  \
 "(non-negative value throws OOM after this many CI accesses "     \
 "in each compile)")                                               \
-\
+notproduct(intx, CICrashAt, -1,                                           \
+"id of compilation to trigger assert in compiler thread for "     \
+"the purpose of testing, e.g. generation of replay data")         \
 notproduct(bool, CIObjectFactoryVerify, false,                            \
 "enable potentially expensive verification in ciObjectFactory")   \
 \
 /* Priorities */                                                          \
 product_pd(bool, UseThreadPriorities,  "Use native thread priorities")    \
 \
 product(intx, Tier0ProfilingStartPercentage, 200,                         \
 "Start profiling in interpreter if the counters exceed tier 3"    \
 "thresholds by the specified percentage")                         \
 \
+product(uintx, IncreaseFirstTierCompileThresholdAt, 50,                   \
+"Increase the compile threshold for C1 compilation if the code"   \
+"cache is filled by the specified percentage.")                   \
+\
 product(intx, TieredRateUpdateMinTime, 1,                                 \
 "Minimum rate sampling interval (in milliseconds)")               \
 \
 product(intx, TieredRateUpdateMaxTime, 25,                                \
 "Maximum rate sampling interval (in milliseconds)")               \
 "Include GC cause in GC logging")                                 \
 \
 product(bool , AllowNonVirtualCalls, false,                               \
 "Obey the ACC_SUPER flag and allow invokenonvirtual calls")       \
 \
-product(bool, TraceWarpLoading, false,                                    \
+diagnostic(ccstr, SharedArchiveFile, NULL,                                \
-"trace external GPU warp loading")                                \
+"Override the default location of the CDS archive file")          \
 \
 experimental(uintx, ArrayAllocatorMallocLimit,                            \
 SOLARIS_ONLY(64*K) NOT_SOLARIS(max_uintx),                        \
 "Allocation less than this value will be allocated "              \
-"using malloc. Larger allocations will use mmap.")
+"using malloc. Larger allocations will use mmap.")                \
+\
+product(bool, EnableTracing, false,                                       \
+"Enable event-based tracing")                                     \
+product(bool, UseLockedTracing, false,                                    \
+"Use locked-tracing when doing event-based tracing")
 /*
 *  Macros for factoring of globals
 */

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/globals.hpp @ 10408:836a62f43af9