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

comparison src/share/vm/runtime/globals.hpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	2c754f3a2722 f5c8d6e5bfee
children	8d88c9ac9247

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
-* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
-#if !defined(COMPILER1) && !defined(COMPILER2)
+#if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK)
 define_pd_global(bool, BackgroundCompilation,        false);
 define_pd_global(bool, UseTLAB,                      false);
 define_pd_global(bool, CICompileOSR,                 false);
 define_pd_global(bool, UseTypeProfile,               false);
 define_pd_global(bool, UseOnStackReplacement,        false);
 define_pd_global(bool, ProfileInterpreter,           false);
 define_pd_global(bool, ProfileTraps,                 false);
 define_pd_global(bool, TieredCompilation,            false);
 define_pd_global(intx, CompileThreshold,             0);
-define_pd_global(intx, Tier2CompileThreshold,        0);
-define_pd_global(intx, Tier3CompileThreshold,        0);
-define_pd_global(intx, Tier4CompileThreshold,        0);
 define_pd_global(intx, BackEdgeThreshold,            0);
-define_pd_global(intx, Tier2BackEdgeThreshold,       0);
-define_pd_global(intx, Tier3BackEdgeThreshold,       0);
-define_pd_global(intx, Tier4BackEdgeThreshold,       0);
 define_pd_global(intx, OnStackReplacePercentage,     0);
 define_pd_global(bool, ResizeTLAB,                   false);
 define_pd_global(intx, FreqInlineSize,               0);
 define_pd_global(intx, InlineSmallCode,              0);
 struct Flag {
 const char *type;
 const char *name;
 void*       addr;
+NOT_PRODUCT(const char *doc;)
 const char *kind;
 FlagValueOrigin origin;
 // points to all Flags static array
 static Flag *flags;
 bool is_unlocker() const;
 bool is_unlocked() const;
 bool is_writeable() const;
 bool is_external() const;
-void print_on(outputStream* st);
+void print_on(outputStream* st, bool withComments = false );
 void print_as_flag(outputStream* st);
 };
 // debug flags control various aspects of the VM and are global accessible
 // Returns false if name is not a command line flag.
 static bool wasSetOnCmdline(const char* name, bool* value);
 static void printSetFlags();
-static void printFlags();
+static void printFlags(bool withComments = false );
 static void verify() PRODUCT_RETURN;
 };
 // use this for flags that are true by default in the debug version but
 //    be able to build a fully supported product that nonetheless also
 //    ships with some unsupported, lightly tested, experimental features.
 //    Like the UnlockDiagnosticVMOptions flag above, there is a corresponding
 //    UnlockExperimentalVMOptions flag, which allows the control and
 //    modification of the experimental flags.
+//
+// Nota bene: neither diagnostic nor experimental options should be used casually,
+//    and they are not supported on production loads, except under explicit
+//    direction from support engineers.
 //
 // manageable flags are writeable external product flags.
 //    They are dynamically writeable through the JDK management interface
 //    (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
 //    These flags are external exported interface (see CCC).  The list of
 "OS specific low limit for heap base address")                  \
 \
 diagnostic(bool, PrintCompressedOopsMode, false,                          \
 "Print compressed oops base address and encoding mode")         \
 \
+lp64_product(intx, ObjectAlignmentInBytes, 8,                             \
+"Default object alignment in bytes, 8 is minimum")                \
+\
 /* UseMembar is theoretically a temp flag used for memory barrier         \
 * removal testing.  It was supposed to be removed before FCS but has     \
 * been re-added (see 6401008) */                                         \
-product(bool, UseMembar, false,                                           \
+product_pd(bool, UseMembar,                                               \
 "(Unstable) Issues membars on thread state transitions")          \
+\
+/* Temporary: See 6948537 */                                              \
+experimental(bool, UseMemSetInBOT, true,                                  \
+"(Unstable) uses memset in BOT updates in GC code")               \
 \
 diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug,                  \
 "Enable normal processing of flags relating to field diagnostics")\
 \
 experimental(bool, UnlockExperimentalVMOptions, false,                    \
 "temporary - see javaClasses.cpp")                                \
 \
 notproduct(bool, PrintMallocFree, false,                                  \
 "Trace calls to C heap malloc/free allocation")                   \
 \
-notproduct(bool, PrintOopAddress, false,                                  \
+product(bool, PrintOopAddress, false,                                     \
 "Always print the location of the oop")                           \
 \
 notproduct(bool, VerifyCodeCacheOften, false,                             \
 "Verify compiled-code cache often")                               \
 \
 "Zap freed VM handle space with 0xBCBCBCBC")                      \
 \
 develop(bool, ZapJNIHandleArea, trueInDebug,                              \
 "Zap freed JNI handle space with 0xFEFEFEFE")                     \
 \
+notproduct(bool, ZapStackSegments, trueInDebug,                           \
+"Zap allocated/freed Stack segments with 0xFADFADED")          \
+\
 develop(bool, ZapUnusedHeapArea, trueInDebug,                             \
 "Zap unused heap space with 0xBAADBABE")                          \
 \
 develop(bool, TraceZapUnusedHeapArea, false,                              \
 "Trace zapping of unused heap space")                             \
 product(bool, PrintGCApplicationConcurrentTime, false,                    \
 "Print the time the application has been running")                \
 \
 product(bool, PrintGCApplicationStoppedTime, false,                       \
 "Print the time the application has been stopped")                \
+\
+notproduct(uintx, ErrorHandlerTest, 0,                                    \
+"If > 0, provokes an error after VM initialization; the value"    \
+"determines which error to provoke.  See test_error_handler()"    \
+"in debug.cpp.")                                                  \
 \
 develop(bool, Verbose, false,                                             \
 "Prints additional debugging information from other modes")       \
 \
 develop(bool, PrintMiscellaneous, false,                                  \
 "Collect and print info on spacing of profiler ticks")            \
 \
 develop(bool, PrintJVMWarnings, false,                                    \
 "Prints warnings for unimplemented JVM functions")                \
 \
+product(bool, PrintWarnings, true,                                        \
+"Prints JVM warnings to output stream")                           \
+\
 notproduct(uintx, WarnOnStalledSpinLock, 0,                               \
 "Prints warnings for stalled SpinLocks")                          \
 \
 develop(bool, InitializeJavaLangSystem, true,                             \
 "Initialize java.lang.System - turn off for individual "          \
 product(intx, EmitSync, 0,                                                \
 "(Unsafe,Unstable) "                                              \
 " Controls emission of inline sync fast-path code")               \
 \
 product(intx, AlwaysInflate, 0, "(Unstable) Force inflation")             \
+\
+product(intx, MonitorBound, 0, "Bound Monitor population")                \
+\
+product(bool, MonitorInUseLists, false, "Track Monitors for Deflation")   \
 \
 product(intx, Atomics, 0,                                                 \
 "(Unsafe,Unstable) Diagnostic - Controls emission of atomics")    \
 \
 product(intx, FenceInstruction, 0,                                        \
 "Force ldc -> ldc_w rewrite during RedefineClasses")              \
 \
 product(intx, TraceRedefineClasses, 0,                                    \
 "Trace level for JVMTI RedefineClasses")                          \
 \
+develop(bool, StressMethodComparator, false,                              \
+"run the MethodComparator on all loaded methods")                 \
+\
 /* change to false by default sometime after Mustang */                   \
 product(bool, VerifyMergedCPBytecodes, true,                              \
 "Verify bytecodes after RedefineClasses constant pool merging")   \
 \
 develop(bool, TraceJNIHandleAllocation, false,                            \
 product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false,        \
 "A System.gc() request invokes a concurrent collection and "      \
 "also unloads classes during such a concurrent gc cycle "         \
 "(effective only when UseConcMarkSweepGC)")                       \
 \
+product(bool, GCLockerInvokesConcurrent, false,                           \
+"The exit of a JNI CS necessitating a scavenge also"              \
+" kicks off a bkgrd concurrent collection")                       \
+\
 develop(bool, UseCMSAdaptiveFreeLists, true,                              \
 "Use Adaptive Free Lists in the CMS generation")                  \
 \
 develop(bool, UseAsyncConcMarkSweepGC, true,                              \
 "Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
 \
 develop(intx, CMSDictionaryChoice, 0,                                     \
 "Use BinaryTreeDictionary as default in the CMS generation")      \
 \
 product(uintx, CMSIndexedFreeListReplenish, 4,                            \
-"Replenish and indexed free list with this number of chunks")     \
+"Replenish an indexed free list with this number of chunks")     \
 \
 product(bool, CMSReplenishIntermediate, true,                             \
 "Replenish all intermediate free-list caches")                    \
 \
 product(bool, CMSSplitIndexedFreeListBlocks, true,                        \
-"When satisfying batched demand, splot blocks from the "          \
+"When satisfying batched demand, split blocks from the "          \
 "IndexedFreeList whose size is a multiple of requested size")     \
 \
 product(bool, CMSLoopWarn, false,                                         \
 "Warn in case of excessive CMS looping")                          \
 \
 \
 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100,              \
 "(Temporary, subject to experimentation)"                         \
 "Nominal minimum work per abortable preclean iteration")          \
 \
-product(intx, CMSAbortablePrecleanWaitMillis, 100,                        \
+manageable(intx, CMSAbortablePrecleanWaitMillis, 100,                     \
 "(Temporary, subject to experimentation)"                         \
 " Time that we sleep between iterations when not given"           \
 " enough work per iteration")                                     \
 \
 product(uintx, CMSRescanMultiple, 32,                                     \
 "Trace some actions of the CMS sweeper")                          \
 \
 product(uintx, CMSWorkQueueDrainThreshold, 10,                            \
 "Don't drain below this size per parallel worker/thief")          \
 \
-product(intx, CMSWaitDuration, 2000,                                      \
+manageable(intx, CMSWaitDuration, 2000,                                   \
 "Time in milliseconds that CMS thread waits for young GC")        \
 \
 product(bool, CMSYield, true,                                             \
 "Yield between steps of concurrent mark & sweep")                 \
 \
 "Do lots of (expensive) FLS dictionary verification")             \
 \
 develop(bool, VerifyBlockOffsetArray, false,                              \
 "Do (expensive!) block offset array verification")                \
 \
-product(bool, BlockOffsetArrayUseUnallocatedBlock, trueInDebug,           \
+product(bool, BlockOffsetArrayUseUnallocatedBlock, false,                 \
 "Maintain _unallocated_block in BlockOffsetArray"                 \
 " (currently applicable only to CMS collector)")                  \
 \
 develop(bool, TraceCMSState, false,                                       \
 "Trace the state of the CMS collection")                          \
 "(N=FullGCALotInterval)")                                         \
 \
 notproduct(bool, GCALotAtAllSafepoints, false,                            \
 "Enforce ScavengeALot/GCALot at all potential safepoints")        \
 \
-product(bool, HandlePromotionFailure, true,                               \
-"The youngest generation collection does not require "            \
-"a guarantee of full promotion of all live objects.")             \
-\
 product(bool, PrintPromotionFailure, false,                               \
 "Print additional diagnostic information following "              \
 " promotion failure")                                             \
 \
 notproduct(bool, PromotionFailureALot, false,                             \
 "(other young collectors) ")                                      \
 \
 develop(uintx, PromotionFailureALotInterval, 5,                           \
 "Total collections between promotion failures alot")              \
 \
-develop(intx, WorkStealingSleepMillis, 1,                                 \
+experimental(intx, WorkStealingSleepMillis, 1,                            \
 "Sleep time when sleep is used for yields")                       \
 \
-develop(uintx, WorkStealingYieldsBeforeSleep, 1000,                       \
+experimental(uintx, WorkStealingYieldsBeforeSleep, 1000,                  \
 "Number of yields before a sleep is done during workstealing")    \
 \
-develop(uintx, WorkStealingHardSpins, 4096,                               \
+experimental(uintx, WorkStealingHardSpins, 4096,                          \
 "Number of iterations in a spin loop between checks on "          \
 "time out of hard spin")                                          \
 \
-develop(uintx, WorkStealingSpinToYieldRatio, 10,                          \
+experimental(uintx, WorkStealingSpinToYieldRatio, 10,                     \
 "Ratio of hard spins to calls to yield")                          \
 \
 product(uintx, PreserveMarkStackSize, 1024,                               \
 "Size for stack used in promotion failure handling")              \
 \
 "Supplement to TenuredGenerationSizeIncrement used at startup")   \
 \
 product(uintx, TenuredGenerationSizeSupplementDecay, 2,                   \
 "Decay factor to TenuredGenerationSizeIncrement")                 \
 \
-product(uintx, MaxGCPauseMillis, max_uintx,                               \
+product(uintx, MaxGCPauseMillis, max_uintx,                           \
 "Adaptive size policy maximum GC pause time goal in msec, "       \
 "or (G1 Only) the max. GC time per MMU time slice")               \
 \
-product(intx, GCPauseIntervalMillis, 500,                                 \
+product(uintx, GCPauseIntervalMillis, 0,                                  \
 "Time slice for MMU specification")                               \
 \
 product(uintx, MaxGCMinorPauseMillis, max_uintx,                          \
 "Adaptive size policy maximum GC minor pause time goal in msec")  \
 \
 "Use inexact types at allocations, etc., to test reflection")     \
 \
 develop(bool, EagerInitialization, false,                                 \
 "Eagerly initialize classes if possible")                         \
 \
-product(bool, Tier1UpdateMethodData, trueInTiered,                        \
-"Update methodDataOops in Tier1-generated code")                  \
-\
 develop(bool, TraceMethodReplacement, false,                              \
 "Print when methods are replaced do to recompilation")            \
 \
 develop(bool, PrintMethodFlushing, false,                                 \
 "print the nmethods being flushed")                               \
 "Print all VM flags before argument processing and exit VM")       \
 \
 product(bool, PrintFlagsFinal, false,                                     \
 "Print all VM flags after argument and ergonomic processing")      \
 \
+notproduct(bool, PrintFlagsWithComments, false,                           \
+"Print all VM flags with default values and descriptions and exit")\
+\
 diagnostic(bool, SerializeVMOutput, true,                                 \
 "Use a mutex to serialize output to tty and hotspot.log")          \
 \
 diagnostic(bool, DisplayVMOutput, true,                                   \
 "Display all VM output on the tty, independently of LogVMOutput")  \
 \
 notproduct(ccstr, AbortVMOnException, NULL,                               \
 "Call fatal if this exception is thrown.  Example: "              \
 "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
 \
+notproduct(ccstr, AbortVMOnExceptionMessage, NULL,                        \
+"Call fatal if the exception pointed by AbortVMOnException "      \
+"has this message.")                                              \
+\
 develop(bool, DebugVtables, false,                                        \
 "add debugging code to vtable dispatch")                          \
 \
 develop(bool, PrintVtables, false,                                        \
 "print vtables when printing klass")                              \
 develop(bool, TypeProfileCasts,  true,                                    \
 "treat casts like calls for purposes of type profiling")          \
 \
 develop(bool, MonomorphicArrayCheck, true,                                \
 "Uncommon-trap array store checks that require full type check")  \
+\
+diagnostic(bool, ProfileDynamicTypes, true,                               \
+"do extra type profiling and use it more aggressively")           \
 \
 develop(bool, DelayCompilationDuringStartup, true,                        \
 "Delay invoking the compiler until main application class is "    \
 "loaded")                                                         \
 \
 \
 product(bool, UseStringCache, false,                                      \
 "Enable String cache capabilities on String.java")                \
 \
 /* statistics */                                                          \
-develop(bool, UseVTune, false,                                            \
-"enable support for Intel's VTune profiler")                      \
-\
 develop(bool, CountCompiledCalls, false,                                  \
 "counts method invocations")                                      \
 \
 notproduct(bool, CountRuntimeCalls, false,                                \
 "counts VM runtime calls")                                        \
 "Delay in milliseconds for option SafepointTimeout")              \
 \
 product(intx, NmethodSweepFraction, 4,                                    \
 "Number of invocations of sweeper to cover all nmethods")         \
 \
+product(intx, NmethodSweepCheckInterval, 5,                               \
+"Compilers wake up every n seconds to possibly sweep nmethods")   \
+\
 notproduct(intx, MemProfilingInterval, 500,                               \
 "Time between each invocation of the MemProfiler")                \
 \
 develop(intx, MallocCatchPtr, -1,                                         \
 "Hit breakpoint when mallocing/freeing this pointer")             \
 \
 diagnostic(intx, MallocVerifyStart,     0,                                \
 "if non-zero, start verifying C heap after Nth call to "          \
 "malloc/realloc/free")                                            \
 \
-product(intx, TypeProfileWidth,      2,                                   \
+product(intx, TypeProfileWidth,     2,                                   \
 "number of receiver types to record in call/cast profile")        \
 \
 develop(intx, BciProfileWidth,      2,                                    \
 "number of return bci's to record in ret profile")                \
 \
 product(intx, SurvivorRatio, 8,                                           \
 "Ratio of eden/survivor space size")                              \
 \
 product(intx, NewRatio, 2,                                                \
 "Ratio of new/old generation sizes")                              \
-\
-product(uintx, MaxLiveObjectEvacuationRatio, 100,                         \
-"Max percent of eden objects that will be live at scavenge")      \
 \
 product_pd(uintx, NewSizeThreadIncrease,                                  \
 "Additional size added to desired new generation size per "       \
 "non-daemon thread (in bytes)")                                   \
 \
 product(intx, DeferPollingPageLoopCount,     -1,                          \
 "(Unsafe,Unstable) Number of iterations in safepoint loop "       \
 "before changing safepoint polling page to RO ")                  \
 \
 product(intx, SafepointSpinBeforeYield, 2000,  "(Unstable)")              \
-\
-product(bool, UseDepthFirstScavengeOrder, true,                           \
-"true: the scavenge order will be depth-first, "                  \
-"false: the scavenge order will be breadth-first")                \
 \
 product(bool, PSChunkLargeArrays, true,                                   \
 "true: process large arrays in chunks")                           \
 \
 product(uintx, GCDrainStackTargetSize, 64,                                \
 "number of interpreted method invocations before (re-)compiling") \
 \
 product_pd(intx, BackEdgeThreshold,                                       \
 "Interpreter Back edge threshold at which an OSR compilation is invoked")\
 \
-product(intx, Tier1BytecodeLimit,      10,                                \
+product(intx, Tier0InvokeNotifyFreqLog, 7,                                \
-"Must have at least this many bytecodes before tier1"             \
+"Interpreter (tier 0) invocation notification frequency.")        \
-"invocation counters are used")                                   \
+\
-\
+product(intx, Tier2InvokeNotifyFreqLog, 11,                               \
-product_pd(intx, Tier2CompileThreshold,                                   \
+"C1 without MDO (tier 2) invocation notification frequency.")     \
-"threshold at which a tier 2 compilation is invoked")             \
+\
-\
+product(intx, Tier3InvokeNotifyFreqLog, 10,                               \
-product_pd(intx, Tier2BackEdgeThreshold,                                  \
+"C1 with MDO profiling (tier 3) invocation notification "         \
-"Back edge threshold at which a tier 2 compilation is invoked")   \
+"frequency.")                                                     \
 \
-product_pd(intx, Tier3CompileThreshold,                                   \
+product(intx, Tier0BackedgeNotifyFreqLog, 10,                             \
-"threshold at which a tier 3 compilation is invoked")             \
+"Interpreter (tier 0) invocation notification frequency.")        \
 \
-product_pd(intx, Tier3BackEdgeThreshold,                                  \
+product(intx, Tier2BackedgeNotifyFreqLog, 14,                             \
-"Back edge threshold at which a tier 3 compilation is invoked")   \
+"C1 without MDO (tier 2) invocation notification frequency.")     \
 \
-product_pd(intx, Tier4CompileThreshold,                                   \
+product(intx, Tier3BackedgeNotifyFreqLog, 13,                             \
-"threshold at which a tier 4 compilation is invoked")             \
+"C1 with MDO profiling (tier 3) invocation notification "         \
-\
+"frequency.")                                                     \
-product_pd(intx, Tier4BackEdgeThreshold,                                  \
+\
-"Back edge threshold at which a tier 4 compilation is invoked")   \
+product(intx, Tier2CompileThreshold, 0,                                   \
+"threshold at which tier 2 compilation is invoked")               \
+\
+product(intx, Tier2BackEdgeThreshold, 0,                                  \
+"Back edge threshold at which tier 2 compilation is invoked")     \
+\
+product(intx, Tier3InvocationThreshold, 200,                              \
+"Compile if number of method invocations crosses this "           \
+"threshold")                                                      \
+\
+product(intx, Tier3MinInvocationThreshold, 100,                           \
+"Minimum invocation to compile at tier 3")                        \
+\
+product(intx, Tier3CompileThreshold, 2000,                                \
+"Threshold at which tier 3 compilation is invoked (invocation "   \
+"minimum must be satisfied.")                                     \
+\
+product(intx, Tier3BackEdgeThreshold,  7000,                              \
+"Back edge threshold at which tier 3 OSR compilation is invoked") \
+\
+product(intx, Tier4InvocationThreshold, 5000,                             \
+"Compile if number of method invocations crosses this "           \
+"threshold")                                                      \
+\
+product(intx, Tier4MinInvocationThreshold, 600,                           \
+"Minimum invocation to compile at tier 4")                        \
+\
+product(intx, Tier4CompileThreshold, 15000,                               \
+"Threshold at which tier 4 compilation is invoked (invocation "   \
+"minimum must be satisfied.")                                     \
+\
+product(intx, Tier4BackEdgeThreshold, 40000,                              \
+"Back edge threshold at which tier 4 OSR compilation is invoked") \
+\
+product(intx, Tier3DelayOn, 5,                                            \
+"If C2 queue size grows over this amount per compiler thread "    \
+"stop compiling at tier 3 and start compiling at tier 2")         \
+\
+product(intx, Tier3DelayOff, 2,                                           \
+"If C2 queue size is less than this amount per compiler thread "  \
+"allow methods compiled at tier 2 transition to tier 3")          \
+\
+product(intx, Tier3LoadFeedback, 5,                                       \
+"Tier 3 thresholds will increase twofold when C1 queue size "     \
+"reaches this amount per compiler thread")                        \
+\
+product(intx, Tier4LoadFeedback, 3,                                       \
+"Tier 4 thresholds will increase twofold when C2 queue size "     \
+"reaches this amount per compiler thread")                        \
+\
+product(intx, TieredCompileTaskTimeout, 50,                               \
+"Kill compile task if method was not used within "                \
+"given timeout in milliseconds")                                  \
+\
+product(intx, TieredStopAtLevel, 4,                                       \
+"Stop at given compilation level")                                \
+\
+product(intx, Tier0ProfilingStartPercentage, 200,                         \
+"Start profiling in interpreter if the counters exceed tier 3"    \
+"thresholds by the specified percentage")                         \
+\
+product(intx, TieredRateUpdateMinTime, 1,                                 \
+"Minimum rate sampling interval (in milliseconds)")               \
+\
+product(intx, TieredRateUpdateMaxTime, 25,                                \
+"Maximum rate sampling interval (in milliseconds)")               \
 \
 product_pd(bool, TieredCompilation,                                       \
-"Enable two-tier compilation")                                    \
+"Enable tiered compilation")                                      \
+\
+product(bool, PrintTieredEvents, false,                                   \
+"Print tiered events notifications")                              \
 \
 product(bool, StressTieredRuntime, false,                                 \
 "Alternate client and server compiler on compile requests")       \
 \
 product_pd(intx, OnStackReplacePercentage,                                \
 "Print usage of shared spaces")                                   \
 \
 product(uintx, SharedDummyBlockSize, 512*M,                               \
 "Size of dummy block used to shift heap addresses (in bytes)")    \
 \
-product(uintx, SharedReadWriteSize,  12*M,                                \
+product(uintx, SharedReadWriteSize,  NOT_LP64(12*M) LP64_ONLY(13*M),      \
 "Size of read-write space in permanent generation (in bytes)")    \
 \
 product(uintx, SharedReadOnlySize,   10*M,                                \
 "Size of read-only space in permanent generation (in bytes)")     \
 \
 "trust final non-static declarations for constant folding")       \
 \
 experimental(bool, EnableInvokeDynamic, false,                            \
 "recognize the invokedynamic instruction")                        \
 \
+experimental(bool, AllowTransitionalJSR292, true,                         \
+"recognize pre-PFD formats of invokedynamic")                     \
+\
 develop(bool, TraceInvokeDynamic, false,                                  \
 "trace internal invoke dynamic operations")                       \
-\
-product(bool, TaggedStackInterpreter, false,                              \
-"Insert tags in interpreter execution stack for oopmap generaion")\
 \
 diagnostic(bool, PauseAtStartup,      false,                              \
 "Causes the VM to pause at startup time and wait for the pause "  \
 "file to be removed (default: ./vm.paused.<pid>)")                \
 \
 \
 product(bool, UseVMInterruptibleIO, false,                                \
 "(Unstable, Solaris-specific) Thread interrupt before or with "   \
 "EINTR for I/O operations results in OS_INTRPT. The default value"\
 " of this flag is true for JDK 6 and earliers")
 /*
 *  Macros for factoring of globals
 */

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/globals.hpp @ 1930:2d26b0046e0d