src/share/vm/runtime/globals.hpp
Index
Unified diffs
Context diffs
Sdiffs
Wdiffs
Patch
New
Old
Previous File
Next File
*** old/src/share/vm/runtime/globals.hpp Sat Jun 13 09:00:29 2015
--- new/src/share/vm/runtime/globals.hpp Sat Jun 13 09:00:29 2015
*** 256,265 ****
--- 256,286 ----
KIND_COMMERCIAL = 1 << 17,
KIND_MASK = ~VALUE_ORIGIN_MASK
};
+ enum Error {
+ // no error
+ SUCCESS = 0,
+ // flag name is missing
+ MISSING_NAME,
+ // flag value is missing
+ MISSING_VALUE,
+ // error parsing the textual form of the value
+ WRONG_FORMAT,
+ // flag is not writeable
+ NON_WRITABLE,
+ // flag value is outside of its bounds
+ OUT_OF_BOUNDS,
+ // flag value violates its constraint
+ VIOLATES_CONSTRAINT,
+ // there is no flag with the given name
+ INVALID_FLAG,
+ // other, unspecified error related to setting the flag
+ ERR_OTHER
+ };
+
const char* _type;
const char* _name;
void* _addr;
NOT_PRODUCT(const char* _doc;)
Flags _flags;
*** 268,277 ****
--- 289,299 ----
static Flag* flags;
// number of flags
static size_t numFlags;
+ static Flag* find_flag(const char* name) { return find_flag(name, strlen(name), true, true); };
static Flag* find_flag(const char* name, size_t length, bool allow_locked = false, bool return_flag = false);
static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);
void check_writable();
*** 343,355 ****
--- 365,392 ----
void unlock_diagnostic();
void get_locked_message(char*, int) const;
void get_locked_message_ext(char*, int) const;
void print_on(outputStream* st, bool withComments = false );
+ // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
+ void print_on(outputStream* st, bool withComments = false, bool printRanges = false);
void print_kind(outputStream* st);
void print_as_flag(outputStream* st);
+
+ static const char* flag_error_str(Flag::Error error) {
+ switch (error) {
+ case Flag::MISSING_NAME: return "MISSING_NAME";
+ case Flag::MISSING_VALUE: return "MISSING_VALUE";
+ case Flag::NON_WRITABLE: return "NON_WRITABLE";
+ case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS";
+ case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT";
+ case Flag::INVALID_FLAG: return "INVALID_FLAG";
+ case Flag::ERR_OTHER: return "ERR_OTHER";
+ case Flag::SUCCESS: return "SUCCESS";
+ default: return "NULL";
+ }
+ }
};
// debug flags control various aspects of the VM and are global accessible
// use FlagSetting to temporarily change some debug flag
*** 411,473 ****
--- 448,518 ----
~SizeTFlagSetting() { *flag = val; }
};
class CommandLineFlags {
public:
static bool boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);
! static bool boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false) { return boolAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin);
! static bool boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); }
static bool intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
! static bool intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false) { return intAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);
! static bool intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); }
static bool uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
! static bool uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false) { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);
! static bool uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); }
static bool intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
! static bool intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false) { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin);
! static bool intxAtPut(const char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); }
static bool uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);
! static bool uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false) { return uintxAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin);
! static bool uintxAtPut(const char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
static bool size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);
! static bool size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false) { return size_tAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin);
! static bool size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }
static bool uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);
! static bool uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin);
! static bool uint64_tAtPut(const char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
static bool doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);
! static bool doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false) { return doubleAt(name, strlen(name), value, allow_locked, return_flag); }
! static bool doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin);
! static bool doubleAtPut(const char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }
+ static bool _finished_initializing;
+ public:
! static Flag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false) { return boolAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin);
+ static Flag::Error boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false) { return intAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);
+ static Flag::Error intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false) { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);
+ static Flag::Error uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false) { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin);
+ static Flag::Error intxAtPut(const char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false) { return uintxAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin);
+ static Flag::Error uintxAtPut(const char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false) { return size_tAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin);
+ static Flag::Error size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin);
+ static Flag::Error uint64_tAtPut(const char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
+
! static Flag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false) { return doubleAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin);
+ static Flag::Error doubleAtPut(const char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }
! static bool ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false);
! static bool ccstrAt(const char* name, ccstr* value, bool allow_locked = false, bool return_flag = false) { return ccstrAt(name, strlen(name), value, allow_locked, return_flag); }
! static Flag::Error ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false);
! static Flag::Error ccstrAt(const char* name, ccstr* value, bool allow_locked = false, bool return_flag = false) { return ccstrAt(name, strlen(name), value, allow_locked, return_flag); }
// Contract: Flag will make private copy of the incoming value.
// Outgoing value is always malloc-ed, and caller MUST call free.
! static bool ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin);
! static bool ccstrAtPut(const char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }
! static Flag::Error ccstrAtPut(const char* name, size_t len, ccstr* value, Flag::Flags origin);
! static Flag::Error ccstrAtPut(const char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }
// Returns false if name is not a command line flag.
static bool wasSetOnCmdline(const char* name, bool* value);
static void printSetFlags(outputStream* out);
static void printFlags(outputStream* out, bool withComments);
+ // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges
+ static void printFlags(outputStream* out, bool withComments, bool printRanges = false);
+
+ // Returns true if all flags have their final values set (ready for ranges and constraint check)
+ static bool finishedInitializing() { return _finished_initializing; }
+
+ // Check the final values of all flags for ranges and constraints
+ static bool check_all_ranges_and_constraints();
static void verify() PRODUCT_RETURN;
};
// use this for flags that are true by default in the debug version but
*** 557,568 ****
--- 602,620 ----
// This implies that the VM must *always* query the flag variable
// and not reuse state related to the flag state at any given time.
//
// Note that when there is a need to support develop flags to be writeable,
// it can be done in the same way as product_rw.
+ //
+ // range is a macro that will expand to min and max arguments for range
+ // checking code if provided - see commandLineFlagRangeList.hpp
+ //
+ // constraint is a macro that will expand to custom function call
+ // for constraint checking if provided - see commandLineFlagConstraintList.hpp
+ //
! #define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product, range, constraint) \
\
lp64_product(bool, UseCompressedOops, false, \
"Use 32-bit object references in 64-bit VM. " \
"lp64_product means flag is always constant in 32 bit VM") \
\
*** 578,600 ****
--- 630,655 ----
\
product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \
"Heap allocation steps through preferred address regions to find" \
" where it can allocate the heap. Number of steps to take per " \
"region.") \
+ range(1, max_uintx) \
\
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") \
+ range(8, 256) \
+ constraint(ObjectAlignmentInBytesConstraintFunc) \
\
product(bool, AssumeMP, false, \
"Instruct the VM to assume multiple processors are available") \
\
! /* 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) */ \
! /* 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_pd(bool, UseMembar, \
"(Unstable) Issues membars on thread state transitions") \
\
develop(bool, CleanChunkPoolAsync, falseInEmbedded, \
"Clean the chunk pool asynchronously") \
*** 647,656 ****
--- 702,712 ----
\
product(uintx, NUMAChunkResizeWeight, 20, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponentially decaying average for " \
"AdaptiveNUMAChunkSizing") \
+ range(0, 100) \
\
product(size_t, NUMASpaceResizeRate, 1*G, \
"Do not reallocate more than this amount per collection") \
\
product(bool, UseAdaptiveNUMAChunkSizing, true, \
*** 857,866 ****
--- 913,923 ----
diagnostic(bool, LogEvents, true, \
"Enable the various ring buffer event logs") \
\
diagnostic(uintx, LogEventsBufferEntries, 10, \
"Number of ring buffer event logs") \
+ range(1, NOT_LP64(1*K) LP64_ONLY(1*M)) \
\
product(bool, BytecodeVerificationRemote, true, \
"Enable the Java bytecode verifier for remote classes") \
\
product(bool, BytecodeVerificationLocal, false, \
*** 1029,1038 ****
--- 1086,1096 ----
\
diagnostic(intx, ScavengeRootsInCode, 2, \
"0: do not allow scavengable oops in the code cache; " \
"1: allow scavenging from the code cache; " \
"2: emit as many constants as the compiler can see") \
+ range(0, 2) \
\
product(bool, AlwaysRestoreFPU, false, \
"Restore the FPU control word after every JNI call (expensive)") \
\
diagnostic(bool, PrintCompilation2, false, \
*** 1302,1322 ****
--- 1360,1388 ----
\
product(bool, UseXMMForArrayCopy, false, \
"Use SSE2 MOVQ instruction for Arraycopy") \
\
product(intx, FieldsAllocationStyle, 1, \
! "0 - type based with oops first, 1 - with oops last, " \
! "0 - type based with oops first, " \
+ "1 - with oops last, " \
"2 - oops in super and sub classes are together") \
+ range(0, 2) \
\
product(bool, CompactFields, true, \
"Allocate nonstatic fields in gaps between previous fields") \
\
notproduct(bool, PrintFieldLayout, false, \
"Print field layout for each class") \
\
+ /* Need to limit the extent of the padding to reasonable size. */\
+ /* 8K is well beyond the reasonable HW cache line size, even with */\
+ /* aggressive prefetching, while still leaving the room for segregating */\
+ /* among the distinct pages. */\
product(intx, ContendedPaddingWidth, 128, \
"How many bytes to pad the fields/classes marked @Contended with")\
+ range(0, 8192) \
+ constraint(ContendedPaddingWidthConstraintFunc) \
\
product(bool, EnableContended, true, \
"Enable @Contended annotation support") \
\
product(bool, RestrictContended, true, \
*** 1474,1487 ****
--- 1540,1555 ----
"for a system GC") \
\
product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
"The mean used by the parallel compact dead wood " \
"limiter (a number between 0-100)") \
+ range(0, 100) \
\
product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
"The standard deviation used by the parallel compact dead wood " \
"limiter (a number between 0-100)") \
+ range(0, 100) \
\
product(uint, ParallelGCThreads, 0, \
"Number of parallel threads parallel gc will use") \
\
product(bool, UseDynamicNumberOfGCThreads, false, \
*** 1493,1512 ****
--- 1561,1582 ----
"parallel threads parallel gc will use to aid debugging") \
\
product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \
"Size of heap (bytes) per GC thread used in calculating the " \
"number of GC threads") \
+ range((uintx)os::vm_page_size(), max_uintx) \
\
product(bool, TraceDynamicGCThreads, false, \
"Trace the dynamic GC thread usage") \
\
develop(bool, ParallelOldGCSplitALot, false, \
"Provoke splitting (copying data from a young gen space to " \
"multiple destination spaces)") \
\
develop(uintx, ParallelOldGCSplitInterval, 3, \
"How often to provoke splitting a young gen space") \
+ range(0, max_uintx) \
\
product(uint, ConcGCThreads, 0, \
"Number of threads concurrent gc will use") \
\
product(size_t, YoungPLABSize, 4096, \
*** 1516,1525 ****
--- 1586,1596 ----
"Size of old gen promotion LAB's (in HeapWords), or Number \
of blocks to attempt to claim when refilling CMS LAB's") \
\
product(uintx, GCTaskTimeStampEntries, 200, \
"Number of time stamp entries per gc worker thread") \
+ range(1, max_uintx) \
\
product(bool, AlwaysTenure, false, \
"Always tenure objects in eden (ParallelGC only)") \
\
product(bool, NeverTenure, false, \
*** 1549,1558 ****
--- 1620,1630 ----
"also kicks off a background concurrent collection") \
\
product(uintx, GCLockerEdenExpansionPercent, 5, \
"How much the GC can expand the eden by while the GC locker " \
"is active (as a percentage)") \
+ range(0, 100) \
\
diagnostic(uintx, GCLockerRetryAllocationCount, 2, \
"Number of times to retry allocations when " \
"blocked by the GC locker") \
\
*** 1574,1601 ****
--- 1646,1677 ----
product(bool, PrintTerminationStats, false, \
"Print termination statistics for parallel collectors") \
\
product(uintx, ParallelGCBufferWastePct, 10, \
"Wasted fraction of parallel allocation buffer") \
+ range(0, 100) \
\
product(uintx, TargetPLABWastePct, 10, \
"Target wasted space in last buffer as percent of overall " \
"allocation") \
+ range(1, 100) \
\
product(uintx, PLABWeight, 75, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponentially decaying average for ResizePLAB") \
+ range(0, 100) \
\
product(bool, ResizePLAB, true, \
"Dynamically resize (survivor space) promotion LAB's") \
\
product(bool, PrintPLAB, false, \
"Print (survivor space) promotion LAB's sizing decisions") \
\
product(intx, ParGCArrayScanChunk, 50, \
"Scan a subset of object array and push remainder, if array is " \
"bigger than this") \
+ range(1, max_intx) \
\
product(bool, ParGCUseLocalOverflow, false, \
"Instead of a global overflow list, use local overflow stacks") \
\
product(bool, ParGCTrimOverflow, true, \
*** 1613,1657 ****
--- 1689,1741 ----
"The desired number of objects to claim from the overflow list") \
\
diagnostic(uintx, ParGCStridesPerThread, 2, \
"The number of strides per worker thread that we divide up the " \
"card table scanning work into") \
+ range(1, max_uintx) \
\
diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
"The number of cards in each chunk of the parallel chunks used " \
"during card table scanning") \
+ range(1, max_intx) \
\
product(uintx, OldPLABWeight, 50, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponentially decaying average for resizing " \
"OldPLABSize") \
+ range(0, 100) \
\
product(bool, ResizeOldPLAB, true, \
"Dynamically resize (old gen) promotion LAB's") \
\
product(bool, PrintOldPLAB, false, \
"Print (old gen) promotion LAB's sizing decisions") \
\
product(size_t, CMSOldPLABMin, 16, \
"Minimum size of CMS gen promotion LAB caches per worker " \
"per block size") \
\
product(size_t, CMSOldPLABMax, 1024, \
"Maximum size of CMS gen promotion LAB caches per worker " \
"per block size") \
+ range(1, max_uintx) \
+ \
+ product(size_t, CMSOldPLABMin, 16, \
+ "Minimum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
+ range(1, max_uintx) \
+ constraint(CMSOldPLABMinConstraintFunc) \
\
product(uintx, CMSOldPLABNumRefills, 4, \
"Nominal number of refills of CMS gen promotion LAB cache " \
"per worker per block size") \
+ range(1, max_uintx) \
\
product(bool, CMSOldPLABResizeQuicker, false, \
"React on-the-fly during a scavenge to a sudden " \
"change in block demand rate") \
\
product(uintx, CMSOldPLABToleranceFactor, 4, \
"The tolerance of the phase-change detector for on-the-fly " \
"PLAB resizing during a scavenge") \
+ range(1, max_uintx) \
\
product(uintx, CMSOldPLABReactivityFactor, 2, \
"The gain in the feedback loop for on-the-fly PLAB resizing " \
"during a scavenge") \
\
*** 1659,1689 ****
--- 1743,1778 ----
"Force all freshly committed pages to be pre-touched") \
\
product_pd(size_t, CMSYoungGenPerWorker, \
"The maximum size of young gen chosen by default per GC worker " \
"thread available") \
+ range(1, max_uintx) \
\
product(uintx, CMSIncrementalSafetyFactor, 10, \
"Percentage (0-100) used to add conservatism when computing the " \
"duty cycle") \
+ range(0, 100) \
\
product(uintx, CMSExpAvgFactor, 50, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponential averages for CMS statistics") \
+ range(0, 100) \
\
product(uintx, CMS_FLSWeight, 75, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponentially decaying averages for CMS FLS " \
"statistics") \
+ range(0, 100) \
\
product(uintx, CMS_FLSPadding, 1, \
"The multiple of deviation from mean to use for buffering " \
"against volatility in free list demand") \
\
product(uintx, FLSCoalescePolicy, 2, \
"CMS: aggressiveness level for coalescing, increasing " \
"from 0 to 4") \
+ range(0, 4) \
\
product(bool, FLSAlwaysCoalesceLarge, false, \
"CMS: larger free blocks are always available for coalescing") \
\
product(double, FLSLargestBlockCoalesceProximity, 0.99, \
*** 1713,1722 ****
--- 1802,1812 ----
\
product(uintx, CMS_SweepWeight, 75, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponentially decaying average for inter-sweep " \
"duration") \
+ range(0, 100) \
\
product(uintx, CMS_SweepPadding, 1, \
"The multiple of deviation from mean to use for buffering " \
"against volatility in inter-sweep duration") \
\
*** 1753,1762 ****
--- 1843,1853 ----
product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
"Size of marking stack") \
\
product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
"Maximum size of marking stack") \
+ range(1, (max_jint - 1)) \
\
notproduct(bool, CMSMarkStackOverflowALot, false, \
"Simulate frequent marking stack / work queue overflow") \
\
notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
*** 1776,1788 ****
--- 1867,1881 ----
"Time that we sleep between iterations when not given " \
"enough work per iteration") \
\
product(size_t, CMSRescanMultiple, 32, \
"Size (in cards) of CMS parallel rescan task") \
+ range(1, max_uintx) \
\
product(size_t, CMSConcMarkMultiple, 32, \
"Size (in cards) of CMS concurrent MT marking task") \
+ range(1, max_uintx) \
\
product(bool, CMSAbortSemantics, false, \
"Whether abort-on-overflow semantics is implemented") \
\
product(bool, CMSParallelInitialMarkEnabled, true, \
*** 1814,1831 ****
--- 1907,1929 ----
product(bool, CMSPrecleaningEnabled, true, \
"Whether concurrent precleaning enabled") \
\
product(uintx, CMSPrecleanIter, 3, \
"Maximum number of precleaning iteration passes") \
+ range(0, 9) \
\
! product(uintx, CMSPrecleanNumerator, 2, \
! product(uintx, CMSPrecleanDenominator, 3, \
"CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
"ratio") \
+ range(1, max_uintx) \
+ constraint(CMSPrecleanDenominatorConstraintFunc) \
\
! product(uintx, CMSPrecleanDenominator, 3, \
! product(uintx, CMSPrecleanNumerator, 2, \
"CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
"ratio") \
+ range(0, max_uintx-1) \
+ constraint(CMSPrecleanNumeratorConstraintFunc) \
\
product(bool, CMSPrecleanRefLists1, true, \
"Preclean ref lists during (initial) preclean phase") \
\
product(bool, CMSPrecleanRefLists2, false, \
*** 1837,1867 ****
--- 1935,1970 ----
product(bool, CMSPrecleanSurvivors2, true, \
"Preclean survivors during abortable preclean phase") \
\
product(uintx, CMSPrecleanThreshold, 1000, \
"Do not iterate again if number of dirty cards is less than this")\
+ range(100, max_uintx) \
\
product(bool, CMSCleanOnEnter, true, \
"Clean-on-enter optimization for reducing number of dirty cards") \
\
product(uintx, CMSRemarkVerifyVariant, 1, \
"Choose variant (1,2) of verification following remark") \
+ range(1, 2) \
\
product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
"If Eden size is below this, do not try to schedule remark") \
\
product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
"The Eden occupancy percentage (0-100) at which " \
"to try and schedule remark pause") \
+ range(0, 100) \
\
product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
"Start sampling eden top at least before young gen " \
"occupancy reaches 1/<ratio> of the size at which " \
"we plan to schedule remark") \
+ range(1, max_uintx) \
\
product(uintx, CMSSamplingGrain, 16*K, \
"The minimum distance between eden samples for CMS (see above)") \
+ range(1, max_uintx) \
\
product(bool, CMSScavengeBeforeRemark, false, \
"Attempt scavenge before the CMS remark step") \
\
develop(bool, CMSTraceSweeper, false, \
*** 1881,1890 ****
--- 1984,1994 ----
"Yield between steps of CMS") \
\
product(size_t, CMSBitMapYieldQuantum, 10*M, \
"Bitmap operations should process at most this many bits " \
"between yields") \
+ range(1, max_uintx) \
\
product(bool, CMSDumpAtPromotionFailure, false, \
"Dump useful information about the state of the CMS old " \
"generation upon a promotion failure") \
\
*** 1920,1965 ****
--- 2024,2077 ----
"Trace the state of the CMS collection") \
\
product(intx, RefDiscoveryPolicy, 0, \
"Select type of reference discovery policy: " \
"reference-based(0) or referent-based(1)") \
+ range(ReferenceProcessor::DiscoveryPolicyMin, \
+ ReferenceProcessor::DiscoveryPolicyMax) \
\
product(bool, ParallelRefProcEnabled, false, \
"Enable parallel reference processing whenever possible") \
\
product(bool, ParallelRefProcBalancingEnabled, true, \
"Enable balancing of reference processing queues") \
\
product(uintx, CMSTriggerRatio, 80, \
"Percentage of MinHeapFreeRatio in CMS generation that is " \
"allocated before a CMS collection cycle commences") \
+ range(0, 100) \
\
product(uintx, CMSBootstrapOccupancy, 50, \
"Percentage CMS generation occupancy at which to " \
"initiate CMS collection for bootstrapping collection stats") \
+ range(0, 100) \
\
product(intx, CMSInitiatingOccupancyFraction, -1, \
"Percentage CMS generation occupancy to start a CMS collection " \
"cycle. A negative value means that CMSTriggerRatio is used") \
+ range(min_intx, 100) \
\
product(uintx, InitiatingHeapOccupancyPercent, 45, \
"Percentage of the (entire) heap occupancy to start a " \
"concurrent GC cycle. It is used by GCs that trigger a " \
"concurrent GC cycle based on the occupancy of the entire heap, " \
"not just one of the generations (e.g., G1). A value of 0 " \
"denotes 'do constant GC cycles'.") \
+ range(0, 100) \
\
manageable(intx, CMSTriggerInterval, -1, \
"Commence a CMS collection cycle (at least) every so many " \
"milliseconds (0 permanently, -1 disabled)") \
+ range(-1, max_intx) \
\
product(bool, UseCMSInitiatingOccupancyOnly, false, \
"Only use occupancy as a criterion for starting a CMS collection")\
\
product(uintx, CMSIsTooFullPercentage, 98, \
"An absolute ceiling above which CMS will always consider the " \
"unloading of classes when class unloading is enabled") \
+ range(0, 100) \
\
develop(bool, CMSTestInFreeList, false, \
"Check if the coalesced range is already in the " \
"free lists as claimed") \
\
*** 2065,2085 ****
--- 2177,2201 ----
"MaxRAM / MaxRAMFraction") \
\
product(uintx, MaxRAMFraction, 4, \
"Maximum fraction (1/n) of real memory used for maximum heap " \
"size") \
+ range(1, max_uintx) \
\
product(uintx, DefaultMaxRAMFraction, 4, \
"Maximum fraction (1/n) of real memory used for maximum heap " \
"size; deprecated: to be renamed to MaxRAMFraction") \
+ range(1, max_uintx) \
\
product(uintx, MinRAMFraction, 2, \
"Minimum fraction (1/n) of real memory used for maximum heap " \
"size on systems with small physical memory size") \
+ range(1, max_uintx) \
\
product(uintx, InitialRAMFraction, 64, \
"Fraction (1/n) of real memory used for initial heap size") \
+ range(1, max_uintx) \
\
develop(uintx, MaxVirtMemFraction, 2, \
"Maximum fraction (1/n) of virtual memory used for ergonomically "\
"determining maximum heap size") \
\
*** 2134,2146 ****
--- 2250,2264 ----
product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
"Use adaptive minimum footprint as a goal") \
\
product(uintx, AdaptiveSizePolicyWeight, 10, \
"Weight given to exponential resizing, between 0 and 100") \
+ range(0, 100) \
\
product(uintx, AdaptiveTimeWeight, 25, \
"Weight given to time in adaptive policy, between 0 and 100") \
+ range(0, 100) \
\
product(uintx, PausePadding, 1, \
"How much buffer to keep for pause time") \
\
product(uintx, PromotedPadding, 3, \
*** 2149,2180 ****
--- 2267,2305 ----
product(uintx, SurvivorPadding, 3, \
"How much buffer to keep for survivor overflow") \
\
product(uintx, ThresholdTolerance, 10, \
"Allowed collection cost difference between generations") \
+ range(0, 100) \
\
product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
"If collection costs are within margin, reduce both by full " \
"delta") \
\
product(uintx, YoungGenerationSizeIncrement, 20, \
"Adaptive size percentage change in young generation") \
+ range(0, 100) \
\
product(uintx, YoungGenerationSizeSupplement, 80, \
"Supplement to YoungedGenerationSizeIncrement used at startup") \
+ range(0, 100) \
\
product(uintx, YoungGenerationSizeSupplementDecay, 8, \
"Decay factor to YoungedGenerationSizeSupplement") \
+ range(1, max_uintx) \
\
product(uintx, TenuredGenerationSizeIncrement, 20, \
"Adaptive size percentage change in tenured generation") \
+ range(0, 100) \
\
product(uintx, TenuredGenerationSizeSupplement, 80, \
"Supplement to TenuredGenerationSizeIncrement used at startup") \
+ range(0, 100) \
\
product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
"Decay factor to TenuredGenerationSizeIncrement") \
+ range(1, max_uintx) \
\
product(uintx, MaxGCPauseMillis, max_uintx, \
"Adaptive size policy maximum GC pause time goal in millisecond, "\
"or (G1 Only) the maximum GC time per MMU time slice") \
\
*** 2188,2197 ****
--- 2313,2323 ----
product(uintx, GCTimeRatio, 99, \
"Adaptive size policy application time to GC time ratio") \
\
product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
"Adaptive size scale down factor for shrinking") \
+ range(1, max_uintx) \
\
product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
"Adaptive size decays the major cost for long major intervals") \
\
product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
*** 2211,2224 ****
--- 2337,2352 ----
"before an OutOfMemory error is thrown") \
\
product(uintx, GCTimeLimit, 98, \
"Limit of the proportion of time spent in GC before " \
"an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
+ range(0, 100) \
\
product(uintx, GCHeapFreeLimit, 2, \
"Minimum percentage of free space after a full GC before an " \
"OutOfMemoryError is thrown (used with GCTimeLimit)") \
+ range(0, 100) \
\
develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
"Number of consecutive collections before gc time limit fires") \
\
product(bool, PrintAdaptiveSizePolicy, false, \
*** 2499,2513 ****
--- 2627,2646 ----
develop(intx, OSROnlyBCI, -1, \
"OSR only at this bci. Negative values mean exclude that bci") \
\
/* compiler */ \
\
+ /* notice: the max range value here is max_jint, not max_intx */ \
+ /* because of overflow issue */ \
product(intx, CICompilerCount, CI_COMPILER_COUNT, \
"Number of compiler threads to run") \
+ range((intx)Arguments::get_min_number_of_compiler_threads(), \
+ max_jint) \
\
product(intx, CompilationPolicyChoice, 0, \
"which compilation policy (0-3)") \
+ range(0, 3) \
\
develop(bool, UseStackBanging, true, \
"use stack banging for stack overflow checks (required for " \
"proper StackOverflow handling; disable only to measure cost " \
"of stackbanging)") \
*** 2620,2629 ****
--- 2753,2765 ----
\
notproduct(bool, PrintFlagsWithComments, false, \
"Print all VM flags with default values and descriptions and " \
"exit") \
\
+ product(bool, PrintFlagsRanges, false, \
+ "Print VM flags and their ranges and exit VM") \
+ \
diagnostic(bool, SerializeVMOutput, true, \
"Use a mutex to serialize output to tty and LogFile") \
\
diagnostic(bool, DisplayVMOutput, true, \
"Display all VM output on the tty, independently of LogVMOutput") \
*** 2858,2867 ****
--- 2994,3004 ----
"Profile deoptimization traps at the bytecode level") \
\
product(intx, ProfileMaturityPercentage, 20, \
"number of method invocations/branches (expressed as % of " \
"CompileThreshold) before using the method's profile") \
+ range(0, 100) \
\
diagnostic(bool, PrintMethodData, false, \
"Print the results of +ProfileInterpreter at end of run") \
\
develop(bool, VerifyDataPointer, trueInDebug, \
*** 2918,2927 ****
--- 3055,3065 ----
product(intx, AllocatePrefetchStyle, 1, \
"0 = no prefetch, " \
"1 = prefetch instructions for each allocation, " \
"2 = use TLAB watermark to gate allocation prefetch, " \
"3 = use BIS instruction on Sparc for allocation prefetch") \
+ range(0, 3) \
\
product(intx, AllocatePrefetchDistance, -1, \
"Distance to prefetch ahead of allocation pointer") \
\
product(intx, AllocatePrefetchLines, 3, \
*** 2964,2973 ****
--- 3102,3112 ----
"Delay in milliseconds for option SafepointTimeout") \
\
product(intx, NmethodSweepActivity, 10, \
"Removes cold nmethods from code cache if > 0. Higher values " \
"result in more aggressive sweeping") \
+ range(0, 2000) \
\
notproduct(bool, LogSweeper, false, \
"Keep a ring buffer of sweeper activity") \
\
notproduct(intx, SweeperLogEntries, 1024, \
*** 3092,3110 ****
--- 3231,3252 ----
develop(intx, BciProfileWidth, 2, \
"Number of return bci's to record in ret profile") \
\
product(intx, PerMethodRecompilationCutoff, 400, \
"After recompiling N times, stay in the interpreter (-1=>'Inf')") \
+ range(-1, max_intx) \
\
product(intx, PerBytecodeRecompilationCutoff, 200, \
"Per-BCI limit on repeated recompilation (-1=>'Inf')") \
+ range(-1, max_intx) \
\
product(intx, PerMethodTrapLimit, 100, \
"Limit on traps (of one kind) in a method (includes inlines)") \
\
experimental(intx, PerMethodSpecTrapLimit, 5000, \
! "Limit on speculative traps (of one kind) in a method (includes inlines)") \
! "Limit on speculative traps (of one kind) in a method " \
+ "(includes inlines)") \
\
product(intx, PerBytecodeTrapLimit, 4, \
"Limit on traps (of one kind) at a particular BCI") \
\
experimental(intx, SpecTrapLimitExtraEntries, 3, \
*** 3153,3171 ****
--- 3295,3319 ----
product(size_t, TLABSize, 0, \
"Starting TLAB size (in bytes); zero means set ergonomically") \
\
product(size_t, MinTLABSize, 2*K, \
"Minimum allowed TLAB size (in bytes)") \
+ range(1, max_uintx) \
\
product(uintx, TLABAllocationWeight, 35, \
"Allocation averaging weight") \
+ range(0, 100) \
\
+ /* Limit the lower bound of this flag to 1 as it is used */ \
+ /* in a division expression. */ \
product(uintx, TLABWasteTargetPercent, 1, \
"Percentage of Eden that can be wasted") \
+ range(1, 100) \
\
product(uintx, TLABRefillWasteFraction, 64, \
"Maximum TLAB waste at a refill (internal fragmentation)") \
+ range(1, max_uintx) \
\
product(uintx, TLABWasteIncrement, 4, \
"Increment allowed waste at slow allocation") \
\
product(uintx, SurvivorRatio, 8, \
*** 3185,3221 ****
--- 3333,3378 ----
"Maximum size of Metaspaces (in bytes)") \
\
product(size_t, CompressedClassSpaceSize, 1*G, \
"Maximum size of class area in Metaspace when compressed " \
"class pointers are used") \
+ range(1*M, 3*G) \
\
manageable(uintx, MinHeapFreeRatio, 40, \
"The minimum percentage of heap free after GC to avoid expansion."\
" For most GCs this applies to the old generation. In G1 and" \
" ParallelGC it applies to the whole heap.") \
+ range(0, 100) \
+ constraint(MinHeapFreeRatioConstraintFunc) \
\
manageable(uintx, MaxHeapFreeRatio, 70, \
"The maximum percentage of heap free after GC to avoid shrinking."\
" For most GCs this applies to the old generation. In G1 and" \
" ParallelGC it applies to the whole heap.") \
+ range(0, 100) \
+ constraint(MaxHeapFreeRatioConstraintFunc) \
\
product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
"Number of milliseconds per MB of free space in the heap") \
\
product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
"The minimum change in heap space due to GC (in bytes)") \
\
product(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
"The minimum expansion of Metaspace (in bytes)") \
\
product(uintx, MinMetaspaceFreeRatio, 40, \
"The minimum percentage of Metaspace free after GC to avoid " \
"expansion") \
\
product(uintx, MaxMetaspaceFreeRatio, 70, \
"The maximum percentage of Metaspace free after GC to avoid " \
"shrinking") \
+ range(0, 100) \
+ constraint(MaxMetaspaceFreeRatioConstraintFunc) \
+ \
+ product(uintx, MinMetaspaceFreeRatio, 40, \
+ "The minimum percentage of Metaspace free after GC to avoid " \
+ "expansion") \
+ range(0, 99) \
+ constraint(MinMetaspaceFreeRatioConstraintFunc) \
\
product(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
"The maximum expansion of Metaspace without full GC (in bytes)") \
\
product(uintx, QueuedAllocationWarningCount, 0, \
*** 3228,3257 ****
--- 3385,3421 ----
diagnostic(intx, VerifyGCLevel, 0, \
"Generation level at which to start +VerifyBefore/AfterGC") \
\
product(uintx, MaxTenuringThreshold, 15, \
"Maximum value for tenuring threshold") \
+ range(0, markOopDesc::max_age + 1) \
+ constraint(MaxTenuringThresholdConstraintFunc) \
\
product(uintx, InitialTenuringThreshold, 7, \
"Initial value for tenuring threshold") \
+ range(0, markOopDesc::max_age + 1) \
+ constraint(InitialTenuringThresholdConstraintFunc) \
\
product(uintx, TargetSurvivorRatio, 50, \
"Desired percentage of survivor space used after scavenge") \
+ range(0, 100) \
\
product(uintx, MarkSweepDeadRatio, 5, \
"Percentage (0-100) of the old gen allowed as dead wood. " \
"Serial mark sweep treats this as both the minimum and maximum " \
"value. " \
"CMS uses this value only if it falls back to mark sweep. " \
"Par compact uses a variable scale based on the density of the " \
"generation and treats this as the maximum value when the heap " \
"is either completely full or completely empty. Par compact " \
"also has a smaller default value; see arguments.cpp.") \
+ range(0, 100) \
\
product(uintx, MarkSweepAlwaysCompactCount, 4, \
"How often should we fully compact the heap (ignoring the dead " \
"space parameters)") \
+ range(1, max_uintx) \
\
product(intx, PrintCMSStatistics, 0, \
"Statistics for CMS") \
\
product(bool, PrintCMSInitiationStatistics, false, \
*** 3287,3303 ****
--- 3451,3471 ----
"during parallel gc") \
\
/* stack parameters */ \
product_pd(intx, StackYellowPages, \
"Number of yellow zone (recoverable overflows) pages") \
+ range(1, max_intx) \
\
product_pd(intx, StackRedPages, \
"Number of red zone (unrecoverable overflows) pages") \
+ range(1, max_intx) \
\
+ /* greater stack shadow pages can't generate instruction to bang stack */ \
product_pd(intx, StackShadowPages, \
"Number of shadow zone (for overflow checking) pages " \
"this should exceed the depth of the VM and native call stack") \
+ range(1, 50) \
\
product_pd(intx, ThreadStackSize, \
"Thread Stack Size (in Kbytes)") \
\
product_pd(intx, VMThreadStackSize, \
*** 3317,3326 ****
--- 3485,3495 ----
/* code cache parameters */ \
/* ppc64/tiered compilation has large code-entry alignment. */ \
develop(uintx, CodeCacheSegmentSize, 64 PPC64_ONLY(+64) NOT_PPC64(TIERED_ONLY(+64)),\
"Code cache segment size (in bytes) - smallest unit of " \
"allocation") \
+ range(1, 1024) \
\
develop_pd(intx, CodeEntryAlignment, \
"Code entry alignment for generated code (in bytes)") \
\
product_pd(intx, OptoLoopAlignment, \
*** 3350,3359 ****
--- 3519,3529 ----
product_pd(uintx, CodeCacheExpansionSize, \
"Code cache expansion size (in bytes)") \
\
develop_pd(uintx, CodeCacheMinBlockLength, \
"Minimum number of segments in a code cache block") \
+ range(1, 100) \
\
notproduct(bool, ExitOnFullCodeCache, false, \
"Exit the VM if we fill the code cache") \
\
product(bool, UseCodeCacheFlushing, true, \
*** 3361,3370 ****
--- 3531,3541 ----
\
product(uintx, StartAggressiveSweepingAt, 10, \
"Start aggressive sweeping if X[%] of the code cache is free." \
"Segmented code cache: X[%] of the non-profiled heap." \
"Non-segmented code cache: X[%] of the total code cache") \
+ range(0, 100) \
\
/* interpreter debugging */ \
develop(intx, BinarySwitchThreshold, 5, \
"Minimal number of lookupswitch entries for rewriting to binary " \
"switch") \
*** 3421,3430 ****
--- 3592,3602 ----
"0 - don't do anything special; " \
"1 - treat all class initializers as empty; " \
"2 - treat class initializers for application classes as empty; " \
"3 - allow all class initializers to run during bootstrap but " \
" pretend they are empty after starting replay") \
+ range(0, 3) \
\
develop(bool, ReplayIgnoreInitErrors, false, \
"Ignore exceptions thrown during initialization for replay") \
\
product(bool, DumpReplayDataOnError, true, \
*** 3465,3474 ****
--- 3637,3647 ----
" native thread priorities. Higher Java thread priorities map "\
" to higher native thread priorities. This policy should be "\
" used with care, as sometimes it can cause performance "\
" degradation in the application and/or the entire system. On "\
" Linux this policy requires root privilege.") \
+ range(0, 1) \
\
product(bool, ThreadPriorityVerbose, false, \
"Print priority changes") \
\
product(intx, CompilerThreadPriority, -1, \
*** 3648,3657 ****
--- 3821,3831 ----
"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") \
+ range(0, 99) \
\
product(intx, TieredRateUpdateMinTime, 1, \
"Minimum rate sampling interval (in milliseconds)") \
\
product(intx, TieredRateUpdateMaxTime, 25, \
*** 3668,3677 ****
--- 3842,3852 ----
"% of CompileThreshold) before (re-)compiling OSR code") \
\
product(intx, InterpreterProfilePercentage, 33, \
"NON_TIERED number of method invocations/branches (expressed as " \
"% of CompileThreshold) before profiling in the interpreter") \
+ range(0, 100) \
\
develop(intx, MaxRecompilationSearchLength, 10, \
"The maximum number of frames to inspect when searching for " \
"recompilee") \
\
*** 3747,3756 ****
--- 3922,3932 ----
"Bypass Win32 file system criteria checks (Windows Only)") \
\
product(intx, UnguardOnExecutionViolation, 0, \
"Unguard page and retry on no-execute fault (Win32 only) " \
"0=off, 1=conservative, 2=aggressive") \
+ range(0, 2) \
\
/* Serviceability Support */ \
\
product(bool, ManagementServer, false, \
"Create JMX Management Server") \
*** 3867,3889 ****
--- 4043,4068 ----
product(bool, RelaxAccessControlCheck, false, \
"Relax the access control checks in the verifier") \
\
product(uintx, StringTableSize, defaultStringTableSize, \
"Number of buckets in the interned String table") \
+ range(minimumStringTableSize, 111*defaultStringTableSize) \
\
experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
"Number of buckets in the JVM internal Symbol table") \
+ range(minimumSymbolTableSize, 111*defaultSymbolTableSize) \
\
product(bool, UseStringDeduplication, false, \
"Use string deduplication") \
\
product(bool, PrintStringDeduplicationStatistics, false, \
"Print string deduplication statistics") \
\
product(uintx, StringDeduplicationAgeThreshold, 3, \
"A string must reach this age (or be promoted to an old region) " \
"to be considered for deduplication") \
+ range(1, markOopDesc::max_age) \
\
diagnostic(bool, StringDeduplicationResizeALot, false, \
"Force table resize every time the table is scanned") \
\
diagnostic(bool, StringDeduplicationRehashALot, false, \
*** 3901,3910 ****
--- 4080,4090 ----
product(bool, PrintGCCause, true, \
"Include GC cause in GC logging") \
\
experimental(intx, SurvivorAlignmentInBytes, 0, \
"Default survivor space alignment in bytes") \
+ constraint(SurvivorAlignmentInBytesConstraintFunc) \
\
product(bool , AllowNonVirtualCalls, false, \
"Obey the ACC_SUPER flag and allow invokenonvirtual calls") \
\
product(ccstr, DumpLoadedClassList, NULL, \
*** 3958,3968 ****
--- 4138,4148 ----
#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type CONST_##name;
#else
#define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name;
#define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name;
#define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name;
! #endif // PRODUCT
// Special LP64 flags, product only needed for now.
#ifdef _LP64
#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) extern "C" type name;
#else
#define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) const type name = value;
*** 3981,4002 ****
--- 4161,4211 ----
#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type CONST_##name = value;
#else
#define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value;
#define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name;
#define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value;
! #endif // PRODUCT
#ifdef _LP64
#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value;
#else
#define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */
#endif // _LP64
RUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG, DECLARE_LP64_PRODUCT_FLAG)
RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)
ARCH_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG)
+ // Only materialize src code for range checking when required, ignore otherwise
+ #define IGNORE_RANGE(a, b)
+ // Only materialize src code for contraint checking when required, ignore otherwise
+ #define IGNORE_CONSTRAINT(func)
+
+ RUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, \
+ DECLARE_PD_DEVELOPER_FLAG, \
+ DECLARE_PRODUCT_FLAG, \
+ DECLARE_PD_PRODUCT_FLAG, \
+ DECLARE_DIAGNOSTIC_FLAG, \
+ DECLARE_EXPERIMENTAL_FLAG, \
+ DECLARE_NOTPRODUCT_FLAG, \
+ DECLARE_MANAGEABLE_FLAG, \
+ DECLARE_PRODUCT_RW_FLAG, \
+ DECLARE_LP64_PRODUCT_FLAG, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT)
+
+ RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, \
+ DECLARE_PD_DEVELOPER_FLAG, \
+ DECLARE_PRODUCT_FLAG, \
+ DECLARE_PD_PRODUCT_FLAG, \
+ DECLARE_DIAGNOSTIC_FLAG, \
+ DECLARE_NOTPRODUCT_FLAG, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT)
+
+ ARCH_FLAGS(DECLARE_DEVELOPER_FLAG, \
+ DECLARE_PRODUCT_FLAG, \
+ DECLARE_DIAGNOSTIC_FLAG, \
+ DECLARE_EXPERIMENTAL_FLAG, \
+ DECLARE_NOTPRODUCT_FLAG, \
+ IGNORE_RANGE, \
+ IGNORE_CONSTRAINT)
// Extensions
#include "runtime/globals_ext.hpp"
src/share/vm/runtime/globals.hpp
Index
Unified diffs
Context diffs
Sdiffs
Wdiffs
Patch
New
Old
Previous File
Next File