Mercurial > jdk8-mips64-public > hotspot / file revision
src/share/vm/runtime/globals.hpp@be3f9c242c9d
src/share/vm/runtime/globals.hpp
Mon, 16 Aug 2010 15:58:42 -0700
- author
- ysr
- date
- Mon, 16 Aug 2010 15:58:42 -0700
- changeset 2071
- be3f9c242c9d
- parent 2068
- 7fcd5f39bd7a
- child 2104
- b4099f5786da
- permissions
- -rw-r--r--
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
Summary: GC workers now recognize an intermediate transient state of blocks which are allocated but have not yet completed initialization. blk_start() calls do not attempt to determine the size of a block in the transient state, rather waiting for the block to become initialized so that it is safe to query its size. Audited and ensured the order of initialization of object fields (klass, free bit and size) to respect block state transition protocol. Also included some new assertion checking code enabled in debug mode.
Reviewed-by: chrisphi, johnc, poonam
1 /*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK)
26 define_pd_global(bool, BackgroundCompilation, false);
27 define_pd_global(bool, UseTLAB, false);
28 define_pd_global(bool, CICompileOSR, false);
29 define_pd_global(bool, UseTypeProfile, false);
30 define_pd_global(bool, UseOnStackReplacement, false);
31 define_pd_global(bool, InlineIntrinsics, false);
32 define_pd_global(bool, PreferInterpreterNativeStubs, true);
33 define_pd_global(bool, ProfileInterpreter, false);
34 define_pd_global(bool, ProfileTraps, false);
35 define_pd_global(bool, TieredCompilation, false);
37 define_pd_global(intx, CompileThreshold, 0);
38 define_pd_global(intx, Tier2CompileThreshold, 0);
39 define_pd_global(intx, Tier3CompileThreshold, 0);
40 define_pd_global(intx, Tier4CompileThreshold, 0);
42 define_pd_global(intx, BackEdgeThreshold, 0);
43 define_pd_global(intx, Tier2BackEdgeThreshold, 0);
44 define_pd_global(intx, Tier3BackEdgeThreshold, 0);
45 define_pd_global(intx, Tier4BackEdgeThreshold, 0);
47 define_pd_global(intx, OnStackReplacePercentage, 0);
48 define_pd_global(bool, ResizeTLAB, false);
49 define_pd_global(intx, FreqInlineSize, 0);
50 define_pd_global(intx, InlineSmallCode, 0);
51 define_pd_global(intx, NewSizeThreadIncrease, 4*K);
52 define_pd_global(intx, InlineClassNatives, true);
53 define_pd_global(intx, InlineUnsafeOps, true);
54 define_pd_global(intx, InitialCodeCacheSize, 160*K);
55 define_pd_global(intx, ReservedCodeCacheSize, 32*M);
56 define_pd_global(intx, CodeCacheExpansionSize, 32*K);
57 define_pd_global(intx, CodeCacheMinBlockLength, 1);
58 define_pd_global(uintx,PermSize, ScaleForWordSize(4*M));
59 define_pd_global(uintx,MaxPermSize, ScaleForWordSize(64*M));
60 define_pd_global(bool, NeverActAsServerClassMachine, true);
61 define_pd_global(uint64_t,MaxRAM, 1ULL*G);
62 #define CI_COMPILER_COUNT 0
63 #else
65 #ifdef COMPILER2
66 #define CI_COMPILER_COUNT 2
67 #else
68 #define CI_COMPILER_COUNT 1
69 #endif // COMPILER2
71 #endif // no compilers
74 // string type aliases used only in this file
75 typedef const char* ccstr;
76 typedef const char* ccstrlist; // represents string arguments which accumulate
78 enum FlagValueOrigin {
79 DEFAULT = 0,
80 COMMAND_LINE = 1,
81 ENVIRON_VAR = 2,
82 CONFIG_FILE = 3,
83 MANAGEMENT = 4,
84 ERGONOMIC = 5,
85 ATTACH_ON_DEMAND = 6,
86 INTERNAL = 99
87 };
89 struct Flag {
90 const char *type;
91 const char *name;
92 void* addr;
93 const char *kind;
94 FlagValueOrigin origin;
96 // points to all Flags static array
97 static Flag *flags;
99 // number of flags
100 static size_t numFlags;
102 static Flag* find_flag(char* name, size_t length);
104 bool is_bool() const { return strcmp(type, "bool") == 0; }
105 bool get_bool() const { return *((bool*) addr); }
106 void set_bool(bool value) { *((bool*) addr) = value; }
108 bool is_intx() const { return strcmp(type, "intx") == 0; }
109 intx get_intx() const { return *((intx*) addr); }
110 void set_intx(intx value) { *((intx*) addr) = value; }
112 bool is_uintx() const { return strcmp(type, "uintx") == 0; }
113 uintx get_uintx() const { return *((uintx*) addr); }
114 void set_uintx(uintx value) { *((uintx*) addr) = value; }
116 bool is_uint64_t() const { return strcmp(type, "uint64_t") == 0; }
117 uint64_t get_uint64_t() const { return *((uint64_t*) addr); }
118 void set_uint64_t(uint64_t value) { *((uint64_t*) addr) = value; }
120 bool is_double() const { return strcmp(type, "double") == 0; }
121 double get_double() const { return *((double*) addr); }
122 void set_double(double value) { *((double*) addr) = value; }
124 bool is_ccstr() const { return strcmp(type, "ccstr") == 0 || strcmp(type, "ccstrlist") == 0; }
125 bool ccstr_accumulates() const { return strcmp(type, "ccstrlist") == 0; }
126 ccstr get_ccstr() const { return *((ccstr*) addr); }
127 void set_ccstr(ccstr value) { *((ccstr*) addr) = value; }
129 bool is_unlocker() const;
130 bool is_unlocked() const;
131 bool is_writeable() const;
132 bool is_external() const;
134 void print_on(outputStream* st);
135 void print_as_flag(outputStream* st);
136 };
138 // debug flags control various aspects of the VM and are global accessible
140 // use FlagSetting to temporarily change some debug flag
141 // e.g. FlagSetting fs(DebugThisAndThat, true);
142 // restored to previous value upon leaving scope
143 class FlagSetting {
144 bool val;
145 bool* flag;
146 public:
147 FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; }
148 ~FlagSetting() { *flag = val; }
149 };
152 class CounterSetting {
153 intx* counter;
154 public:
155 CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }
156 ~CounterSetting() { (*counter)--; }
157 };
160 class IntFlagSetting {
161 intx val;
162 intx* flag;
163 public:
164 IntFlagSetting(intx& fl, intx newValue) { flag = &fl; val = fl; fl = newValue; }
165 ~IntFlagSetting() { *flag = val; }
166 };
169 class DoubleFlagSetting {
170 double val;
171 double* flag;
172 public:
173 DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; }
174 ~DoubleFlagSetting() { *flag = val; }
175 };
178 class CommandLineFlags {
179 public:
180 static bool boolAt(char* name, size_t len, bool* value);
181 static bool boolAt(char* name, bool* value) { return boolAt(name, strlen(name), value); }
182 static bool boolAtPut(char* name, size_t len, bool* value, FlagValueOrigin origin);
183 static bool boolAtPut(char* name, bool* value, FlagValueOrigin origin) { return boolAtPut(name, strlen(name), value, origin); }
185 static bool intxAt(char* name, size_t len, intx* value);
186 static bool intxAt(char* name, intx* value) { return intxAt(name, strlen(name), value); }
187 static bool intxAtPut(char* name, size_t len, intx* value, FlagValueOrigin origin);
188 static bool intxAtPut(char* name, intx* value, FlagValueOrigin origin) { return intxAtPut(name, strlen(name), value, origin); }
190 static bool uintxAt(char* name, size_t len, uintx* value);
191 static bool uintxAt(char* name, uintx* value) { return uintxAt(name, strlen(name), value); }
192 static bool uintxAtPut(char* name, size_t len, uintx* value, FlagValueOrigin origin);
193 static bool uintxAtPut(char* name, uintx* value, FlagValueOrigin origin) { return uintxAtPut(name, strlen(name), value, origin); }
195 static bool uint64_tAt(char* name, size_t len, uint64_t* value);
196 static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }
197 static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin);
198 static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
200 static bool doubleAt(char* name, size_t len, double* value);
201 static bool doubleAt(char* name, double* value) { return doubleAt(name, strlen(name), value); }
202 static bool doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin);
203 static bool doubleAtPut(char* name, double* value, FlagValueOrigin origin) { return doubleAtPut(name, strlen(name), value, origin); }
205 static bool ccstrAt(char* name, size_t len, ccstr* value);
206 static bool ccstrAt(char* name, ccstr* value) { return ccstrAt(name, strlen(name), value); }
207 static bool ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin);
208 static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin origin) { return ccstrAtPut(name, strlen(name), value, origin); }
210 // Returns false if name is not a command line flag.
211 static bool wasSetOnCmdline(const char* name, bool* value);
212 static void printSetFlags();
214 static void printFlags();
216 static void verify() PRODUCT_RETURN;
217 };
219 // use this for flags that are true by default in the debug version but
220 // false in the optimized version, and vice versa
221 #ifdef ASSERT
222 #define trueInDebug true
223 #define falseInDebug false
224 #else
225 #define trueInDebug false
226 #define falseInDebug true
227 #endif
229 // use this for flags that are true per default in the product build
230 // but false in development builds, and vice versa
231 #ifdef PRODUCT
232 #define trueInProduct true
233 #define falseInProduct false
234 #else
235 #define trueInProduct false
236 #define falseInProduct true
237 #endif
239 // use this for flags that are true per default in the tiered build
240 // but false in non-tiered builds, and vice versa
241 #ifdef TIERED
242 #define trueInTiered true
243 #define falseInTiered false
244 #else
245 #define trueInTiered false
246 #define falseInTiered true
247 #endif
249 // develop flags are settable / visible only during development and are constant in the PRODUCT version
250 // product flags are always settable / visible
251 // notproduct flags are settable / visible only during development and are not declared in the PRODUCT version
253 // A flag must be declared with one of the following types:
254 // bool, intx, uintx, ccstr.
255 // The type "ccstr" is an alias for "const char*" and is used
256 // only in this file, because the macrology requires single-token type names.
258 // Note: Diagnostic options not meant for VM tuning or for product modes.
259 // They are to be used for VM quality assurance or field diagnosis
260 // of VM bugs. They are hidden so that users will not be encouraged to
261 // try them as if they were VM ordinary execution options. However, they
262 // are available in the product version of the VM. Under instruction
263 // from support engineers, VM customers can turn them on to collect
264 // diagnostic information about VM problems. To use a VM diagnostic
265 // option, you must first specify +UnlockDiagnosticVMOptions.
266 // (This master switch also affects the behavior of -Xprintflags.)
267 //
268 // experimental flags are in support of features that are not
269 // part of the officially supported product, but are available
270 // for experimenting with. They could, for example, be performance
271 // features that may not have undergone full or rigorous QA, but which may
272 // help performance in some cases and released for experimentation
273 // by the community of users and developers. This flag also allows one to
274 // be able to build a fully supported product that nonetheless also
275 // ships with some unsupported, lightly tested, experimental features.
276 // Like the UnlockDiagnosticVMOptions flag above, there is a corresponding
277 // UnlockExperimentalVMOptions flag, which allows the control and
278 // modification of the experimental flags.
279 //
280 // manageable flags are writeable external product flags.
281 // They are dynamically writeable through the JDK management interface
282 // (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
283 // These flags are external exported interface (see CCC). The list of
284 // manageable flags can be queried programmatically through the management
285 // interface.
286 //
287 // A flag can be made as "manageable" only if
288 // - the flag is defined in a CCC as an external exported interface.
289 // - the VM implementation supports dynamic setting of the flag.
290 // This implies that the VM must *always* query the flag variable
291 // and not reuse state related to the flag state at any given time.
292 // - you want the flag to be queried programmatically by the customers.
293 //
294 // product_rw flags are writeable internal product flags.
295 // They are like "manageable" flags but for internal/private use.
296 // The list of product_rw flags are internal/private flags which
297 // may be changed/removed in a future release. It can be set
298 // through the management interface to get/set value
299 // when the name of flag is supplied.
300 //
301 // A flag can be made as "product_rw" only if
302 // - the VM implementation supports dynamic setting of the flag.
303 // This implies that the VM must *always* query the flag variable
304 // and not reuse state related to the flag state at any given time.
305 //
306 // Note that when there is a need to support develop flags to be writeable,
307 // it can be done in the same way as product_rw.
309 #define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product) \
310 \
311 lp64_product(bool, UseCompressedOops, false, \
312 "Use 32-bit object references in 64-bit VM. " \
313 "lp64_product means flag is always constant in 32 bit VM") \
314 \
315 notproduct(bool, CheckCompressedOops, true, \
316 "generate checks in encoding/decoding code in debug VM") \
317 \
318 product_pd(uintx, HeapBaseMinAddress, \
319 "OS specific low limit for heap base address") \
320 \
321 diagnostic(bool, PrintCompressedOopsMode, false, \
322 "Print compressed oops base address and encoding mode") \
323 \
324 lp64_product(intx, ObjectAlignmentInBytes, 8, \
325 "Default object alignment in bytes, 8 is minimum") \
326 \
327 /* UseMembar is theoretically a temp flag used for memory barrier \
328 * removal testing. It was supposed to be removed before FCS but has \
329 * been re-added (see 6401008) */ \
330 product(bool, UseMembar, false, \
331 "(Unstable) Issues membars on thread state transitions") \
332 \
333 /* Temporary: See 6948537 */ \
334 experimental(bool, UseMemSetInBOT, true, \
335 "(Unstable) uses memset in BOT updates in GC code") \
336 \
337 diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug, \
338 "Enable normal processing of flags relating to field diagnostics")\
339 \
340 experimental(bool, UnlockExperimentalVMOptions, false, \
341 "Enable normal processing of flags relating to experimental features")\
342 \
343 product(bool, JavaMonitorsInStackTrace, true, \
344 "Print info. about Java monitor locks when the stacks are dumped")\
345 \
346 product_pd(bool, UseLargePages, \
347 "Use large page memory") \
348 \
349 product_pd(bool, UseLargePagesIndividualAllocation, \
350 "Allocate large pages individually for better affinity") \
351 \
352 develop(bool, LargePagesIndividualAllocationInjectError, false, \
353 "Fail large pages individual allocation") \
354 \
355 develop(bool, TracePageSizes, false, \
356 "Trace page size selection and usage.") \
357 \
358 product(bool, UseNUMA, false, \
359 "Use NUMA if available") \
360 \
361 product(bool, ForceNUMA, false, \
362 "Force NUMA optimizations on single-node/UMA systems") \
363 \
364 product(intx, NUMAChunkResizeWeight, 20, \
365 "Percentage (0-100) used to weight the current sample when " \
366 "computing exponentially decaying average for " \
367 "AdaptiveNUMAChunkSizing") \
368 \
369 product(intx, NUMASpaceResizeRate, 1*G, \
370 "Do not reallocate more that this amount per collection") \
371 \
372 product(bool, UseAdaptiveNUMAChunkSizing, true, \
373 "Enable adaptive chunk sizing for NUMA") \
374 \
375 product(bool, NUMAStats, false, \
376 "Print NUMA stats in detailed heap information") \
377 \
378 product(intx, NUMAPageScanRate, 256, \
379 "Maximum number of pages to include in the page scan procedure") \
380 \
381 product_pd(bool, NeedsDeoptSuspend, \
382 "True for register window machines (sparc/ia64)") \
383 \
384 product(intx, UseSSE, 99, \
385 "Highest supported SSE instructions set on x86/x64") \
386 \
387 product(uintx, LargePageSizeInBytes, 0, \
388 "Large page size (0 to let VM choose the page size") \
389 \
390 product(uintx, LargePageHeapSizeThreshold, 128*M, \
391 "Use large pages if max heap is at least this big") \
392 \
393 product(bool, ForceTimeHighResolution, false, \
394 "Using high time resolution(For Win32 only)") \
395 \
396 develop(bool, TraceItables, false, \
397 "Trace initialization and use of itables") \
398 \
399 develop(bool, TracePcPatching, false, \
400 "Trace usage of frame::patch_pc") \
401 \
402 develop(bool, TraceJumps, false, \
403 "Trace assembly jumps in thread ring buffer") \
404 \
405 develop(bool, TraceRelocator, false, \
406 "Trace the bytecode relocator") \
407 \
408 develop(bool, TraceLongCompiles, false, \
409 "Print out every time compilation is longer than " \
410 "a given threashold") \
411 \
412 develop(bool, SafepointALot, false, \
413 "Generates a lot of safepoints. Works with " \
414 "GuaranteedSafepointInterval") \
415 \
416 product_pd(bool, BackgroundCompilation, \
417 "A thread requesting compilation is not blocked during " \
418 "compilation") \
419 \
420 product(bool, PrintVMQWaitTime, false, \
421 "Prints out the waiting time in VM operation queue") \
422 \
423 develop(bool, BailoutToInterpreterForThrows, false, \
424 "Compiled methods which throws/catches exceptions will be " \
425 "deopt and intp.") \
426 \
427 develop(bool, NoYieldsInMicrolock, false, \
428 "Disable yields in microlock") \
429 \
430 develop(bool, TraceOopMapGeneration, false, \
431 "Shows oopmap generation") \
432 \
433 product(bool, MethodFlushing, true, \
434 "Reclamation of zombie and not-entrant methods") \
435 \
436 develop(bool, VerifyStack, false, \
437 "Verify stack of each thread when it is entering a runtime call") \
438 \
439 develop(bool, ForceUnreachable, false, \
440 "(amd64) Make all non code cache addresses to be unreachable with rip-rel forcing use of 64bit literal fixups") \
441 \
442 notproduct(bool, StressDerivedPointers, false, \
443 "Force scavenge when a derived pointers is detected on stack " \
444 "after rtm call") \
445 \
446 develop(bool, TraceDerivedPointers, false, \
447 "Trace traversal of derived pointers on stack") \
448 \
449 notproduct(bool, TraceCodeBlobStacks, false, \
450 "Trace stack-walk of codeblobs") \
451 \
452 product(bool, PrintJNIResolving, false, \
453 "Used to implement -v:jni") \
454 \
455 notproduct(bool, PrintRewrites, false, \
456 "Print methods that are being rewritten") \
457 \
458 product(bool, UseInlineCaches, true, \
459 "Use Inline Caches for virtual calls ") \
460 \
461 develop(bool, InlineArrayCopy, true, \
462 "inline arraycopy native that is known to be part of " \
463 "base library DLL") \
464 \
465 develop(bool, InlineObjectHash, true, \
466 "inline Object::hashCode() native that is known to be part " \
467 "of base library DLL") \
468 \
469 develop(bool, InlineObjectCopy, true, \
470 "inline Object.clone and Arrays.copyOf[Range] intrinsics") \
471 \
472 develop(bool, InlineNatives, true, \
473 "inline natives that are known to be part of base library DLL") \
474 \
475 develop(bool, InlineMathNatives, true, \
476 "inline SinD, CosD, etc.") \
477 \
478 develop(bool, InlineClassNatives, true, \
479 "inline Class.isInstance, etc") \
480 \
481 develop(bool, InlineAtomicLong, true, \
482 "inline sun.misc.AtomicLong") \
483 \
484 develop(bool, InlineThreadNatives, true, \
485 "inline Thread.currentThread, etc") \
486 \
487 develop(bool, InlineReflectionGetCallerClass, true, \
488 "inline sun.reflect.Reflection.getCallerClass(), known to be part "\
489 "of base library DLL") \
490 \
491 develop(bool, InlineUnsafeOps, true, \
492 "inline memory ops (native methods) from sun.misc.Unsafe") \
493 \
494 develop(bool, ConvertCmpD2CmpF, true, \
495 "Convert cmpD to cmpF when one input is constant in float range") \
496 \
497 develop(bool, ConvertFloat2IntClipping, true, \
498 "Convert float2int clipping idiom to integer clipping") \
499 \
500 develop(bool, SpecialStringCompareTo, true, \
501 "special version of string compareTo") \
502 \
503 develop(bool, SpecialStringIndexOf, true, \
504 "special version of string indexOf") \
505 \
506 develop(bool, SpecialStringEquals, true, \
507 "special version of string equals") \
508 \
509 develop(bool, SpecialArraysEquals, true, \
510 "special version of Arrays.equals(char[],char[])") \
511 \
512 product(bool, UseSSE42Intrinsics, false, \
513 "SSE4.2 versions of intrinsics") \
514 \
515 develop(bool, TraceCallFixup, false, \
516 "traces all call fixups") \
517 \
518 develop(bool, DeoptimizeALot, false, \
519 "deoptimize at every exit from the runtime system") \
520 \
521 notproduct(ccstrlist, DeoptimizeOnlyAt, "", \
522 "a comma separated list of bcis to deoptimize at") \
523 \
524 product(bool, DeoptimizeRandom, false, \
525 "deoptimize random frames on random exit from the runtime system")\
526 \
527 notproduct(bool, ZombieALot, false, \
528 "creates zombies (non-entrant) at exit from the runt. system") \
529 \
530 notproduct(bool, WalkStackALot, false, \
531 "trace stack (no print) at every exit from the runtime system") \
532 \
533 develop(bool, Debugging, false, \
534 "set when executing debug methods in debug.ccp " \
535 "(to prevent triggering assertions)") \
536 \
537 notproduct(bool, StrictSafepointChecks, trueInDebug, \
538 "Enable strict checks that safepoints cannot happen for threads " \
539 "that used No_Safepoint_Verifier") \
540 \
541 notproduct(bool, VerifyLastFrame, false, \
542 "Verify oops on last frame on entry to VM") \
543 \
544 develop(bool, TraceHandleAllocation, false, \
545 "Prints out warnings when suspicious many handles are allocated") \
546 \
547 product(bool, UseCompilerSafepoints, true, \
548 "Stop at safepoints in compiled code") \
549 \
550 product(bool, UseSplitVerifier, true, \
551 "use split verifier with StackMapTable attributes") \
552 \
553 product(bool, FailOverToOldVerifier, true, \
554 "fail over to old verifier when split verifier fails") \
555 \
556 develop(bool, ShowSafepointMsgs, false, \
557 "Show msg. about safepoint synch.") \
558 \
559 product(bool, SafepointTimeout, false, \
560 "Time out and warn or fail after SafepointTimeoutDelay " \
561 "milliseconds if failed to reach safepoint") \
562 \
563 develop(bool, DieOnSafepointTimeout, false, \
564 "Die upon failure to reach safepoint (see SafepointTimeout)") \
565 \
566 /* 50 retries * (5 * current_retry_count) millis = ~6.375 seconds */ \
567 /* typically, at most a few retries are needed */ \
568 product(intx, SuspendRetryCount, 50, \
569 "Maximum retry count for an external suspend request") \
570 \
571 product(intx, SuspendRetryDelay, 5, \
572 "Milliseconds to delay per retry (* current_retry_count)") \
573 \
574 product(bool, AssertOnSuspendWaitFailure, false, \
575 "Assert/Guarantee on external suspend wait failure") \
576 \
577 product(bool, TraceSuspendWaitFailures, false, \
578 "Trace external suspend wait failures") \
579 \
580 product(bool, MaxFDLimit, true, \
581 "Bump the number of file descriptors to max in solaris.") \
582 \
583 notproduct(bool, LogEvents, trueInDebug, \
584 "Enable Event log") \
585 \
586 product(bool, BytecodeVerificationRemote, true, \
587 "Enables the Java bytecode verifier for remote classes") \
588 \
589 product(bool, BytecodeVerificationLocal, false, \
590 "Enables the Java bytecode verifier for local classes") \
591 \
592 develop(bool, ForceFloatExceptions, trueInDebug, \
593 "Force exceptions on FP stack under/overflow") \
594 \
595 develop(bool, SoftMatchFailure, trueInProduct, \
596 "If the DFA fails to match a node, print a message and bail out") \
597 \
598 develop(bool, VerifyStackAtCalls, false, \
599 "Verify that the stack pointer is unchanged after calls") \
600 \
601 develop(bool, TraceJavaAssertions, false, \
602 "Trace java language assertions") \
603 \
604 notproduct(bool, CheckAssertionStatusDirectives, false, \
605 "temporary - see javaClasses.cpp") \
606 \
607 notproduct(bool, PrintMallocFree, false, \
608 "Trace calls to C heap malloc/free allocation") \
609 \
610 product(bool, PrintOopAddress, false, \
611 "Always print the location of the oop") \
612 \
613 notproduct(bool, VerifyCodeCacheOften, false, \
614 "Verify compiled-code cache often") \
615 \
616 develop(bool, ZapDeadCompiledLocals, false, \
617 "Zap dead locals in compiler frames") \
618 \
619 notproduct(bool, ZapDeadLocalsOld, false, \
620 "Zap dead locals (old version, zaps all frames when " \
621 "entering the VM") \
622 \
623 notproduct(bool, CheckOopishValues, false, \
624 "Warn if value contains oop ( requires ZapDeadLocals)") \
625 \
626 develop(bool, UseMallocOnly, false, \
627 "use only malloc/free for allocation (no resource area/arena)") \
628 \
629 develop(bool, PrintMalloc, false, \
630 "print all malloc/free calls") \
631 \
632 develop(bool, ZapResourceArea, trueInDebug, \
633 "Zap freed resource/arena space with 0xABABABAB") \
634 \
635 notproduct(bool, ZapVMHandleArea, trueInDebug, \
636 "Zap freed VM handle space with 0xBCBCBCBC") \
637 \
638 develop(bool, ZapJNIHandleArea, trueInDebug, \
639 "Zap freed JNI handle space with 0xFEFEFEFE") \
640 \
641 develop(bool, ZapUnusedHeapArea, trueInDebug, \
642 "Zap unused heap space with 0xBAADBABE") \
643 \
644 develop(bool, TraceZapUnusedHeapArea, false, \
645 "Trace zapping of unused heap space") \
646 \
647 develop(bool, CheckZapUnusedHeapArea, false, \
648 "Check zapping of unused heap space") \
649 \
650 develop(bool, ZapFillerObjects, trueInDebug, \
651 "Zap filler objects with 0xDEAFBABE") \
652 \
653 develop(bool, PrintVMMessages, true, \
654 "Print vm messages on console") \
655 \
656 product(bool, PrintGCApplicationConcurrentTime, false, \
657 "Print the time the application has been running") \
658 \
659 product(bool, PrintGCApplicationStoppedTime, false, \
660 "Print the time the application has been stopped") \
661 \
662 notproduct(uintx, ErrorHandlerTest, 0, \
663 "If > 0, provokes an error after VM initialization; the value" \
664 "determines which error to provoke. See test_error_handler()" \
665 "in debug.cpp.") \
666 \
667 develop(bool, Verbose, false, \
668 "Prints additional debugging information from other modes") \
669 \
670 develop(bool, PrintMiscellaneous, false, \
671 "Prints uncategorized debugging information (requires +Verbose)") \
672 \
673 develop(bool, WizardMode, false, \
674 "Prints much more debugging information") \
675 \
676 product(bool, ShowMessageBoxOnError, false, \
677 "Keep process alive on VM fatal error") \
678 \
679 product_pd(bool, UseOSErrorReporting, \
680 "Let VM fatal error propagate to the OS (ie. WER on Windows)") \
681 \
682 product(bool, SuppressFatalErrorMessage, false, \
683 "Do NO Fatal Error report [Avoid deadlock]") \
684 \
685 product(ccstrlist, OnError, "", \
686 "Run user-defined commands on fatal error; see VMError.cpp " \
687 "for examples") \
688 \
689 product(ccstrlist, OnOutOfMemoryError, "", \
690 "Run user-defined commands on first java.lang.OutOfMemoryError") \
691 \
692 manageable(bool, HeapDumpBeforeFullGC, false, \
693 "Dump heap to file before any major stop-world GC") \
694 \
695 manageable(bool, HeapDumpAfterFullGC, false, \
696 "Dump heap to file after any major stop-world GC") \
697 \
698 manageable(bool, HeapDumpOnOutOfMemoryError, false, \
699 "Dump heap to file when java.lang.OutOfMemoryError is thrown") \
700 \
701 manageable(ccstr, HeapDumpPath, NULL, \
702 "When HeapDumpOnOutOfMemoryError is on, the path (filename or" \
703 "directory) of the dump file (defaults to java_pid<pid>.hprof" \
704 "in the working directory)") \
705 \
706 develop(uintx, SegmentedHeapDumpThreshold, 2*G, \
707 "Generate a segmented heap dump (JAVA PROFILE 1.0.2 format) " \
708 "when the heap usage is larger than this") \
709 \
710 develop(uintx, HeapDumpSegmentSize, 1*G, \
711 "Approximate segment size when generating a segmented heap dump") \
712 \
713 develop(bool, BreakAtWarning, false, \
714 "Execute breakpoint upon encountering VM warning") \
715 \
716 product_pd(bool, UseVectoredExceptions, \
717 "Temp Flag - Use Vectored Exceptions rather than SEH (Windows Only)") \
718 \
719 develop(bool, TraceVMOperation, false, \
720 "Trace vm operations") \
721 \
722 develop(bool, UseFakeTimers, false, \
723 "Tells whether the VM should use system time or a fake timer") \
724 \
725 diagnostic(bool, LogCompilation, false, \
726 "Log compilation activity in detail to hotspot.log or LogFile") \
727 \
728 product(bool, PrintCompilation, false, \
729 "Print compilations") \
730 \
731 diagnostic(bool, TraceNMethodInstalls, false, \
732 "Trace nmethod intallation") \
733 \
734 diagnostic(intx, ScavengeRootsInCode, 0, \
735 "0: do not allow scavengable oops in the code cache; " \
736 "1: allow scavenging from the code cache; " \
737 "2: emit as many constants as the compiler can see") \
738 \
739 diagnostic(bool, TraceOSRBreakpoint, false, \
740 "Trace OSR Breakpoint ") \
741 \
742 diagnostic(bool, TraceCompileTriggered, false, \
743 "Trace compile triggered") \
744 \
745 diagnostic(bool, TraceTriggers, false, \
746 "Trace triggers") \
747 \
748 product(bool, AlwaysRestoreFPU, false, \
749 "Restore the FPU control word after every JNI call (expensive)") \
750 \
751 notproduct(bool, PrintCompilation2, false, \
752 "Print additional statistics per compilation") \
753 \
754 diagnostic(bool, PrintAdapterHandlers, false, \
755 "Print code generated for i2c/c2i adapters") \
756 \
757 develop(bool, VerifyAdapterSharing, false, \
758 "Verify that the code for shared adapters is the equivalent") \
759 \
760 diagnostic(bool, PrintAssembly, false, \
761 "Print assembly code (using external disassembler.so)") \
762 \
763 diagnostic(ccstr, PrintAssemblyOptions, NULL, \
764 "Options string passed to disassembler.so") \
765 \
766 diagnostic(bool, PrintNMethods, false, \
767 "Print assembly code for nmethods when generated") \
768 \
769 diagnostic(bool, PrintNativeNMethods, false, \
770 "Print assembly code for native nmethods when generated") \
771 \
772 develop(bool, PrintDebugInfo, false, \
773 "Print debug information for all nmethods when generated") \
774 \
775 develop(bool, PrintRelocations, false, \
776 "Print relocation information for all nmethods when generated") \
777 \
778 develop(bool, PrintDependencies, false, \
779 "Print dependency information for all nmethods when generated") \
780 \
781 develop(bool, PrintExceptionHandlers, false, \
782 "Print exception handler tables for all nmethods when generated") \
783 \
784 develop(bool, InterceptOSException, false, \
785 "Starts debugger when an implicit OS (e.g., NULL) " \
786 "exception happens") \
787 \
788 notproduct(bool, PrintCodeCache, false, \
789 "Print the compiled_code cache when exiting") \
790 \
791 develop(bool, PrintCodeCache2, false, \
792 "Print detailed info on the compiled_code cache when exiting") \
793 \
794 diagnostic(bool, PrintStubCode, false, \
795 "Print generated stub code") \
796 \
797 product(bool, StackTraceInThrowable, true, \
798 "Collect backtrace in throwable when exception happens") \
799 \
800 product(bool, OmitStackTraceInFastThrow, true, \
801 "Omit backtraces for some 'hot' exceptions in optimized code") \
802 \
803 product(bool, ProfilerPrintByteCodeStatistics, false, \
804 "Prints byte code statictics when dumping profiler output") \
805 \
806 product(bool, ProfilerRecordPC, false, \
807 "Collects tick for each 16 byte interval of compiled code") \
808 \
809 product(bool, ProfileVM, false, \
810 "Profiles ticks that fall within VM (either in the VM Thread " \
811 "or VM code called through stubs)") \
812 \
813 product(bool, ProfileIntervals, false, \
814 "Prints profiles for each interval (see ProfileIntervalsTicks)") \
815 \
816 notproduct(bool, ProfilerCheckIntervals, false, \
817 "Collect and print info on spacing of profiler ticks") \
818 \
819 develop(bool, PrintJVMWarnings, false, \
820 "Prints warnings for unimplemented JVM functions") \
821 \
822 notproduct(uintx, WarnOnStalledSpinLock, 0, \
823 "Prints warnings for stalled SpinLocks") \
824 \
825 develop(bool, InitializeJavaLangSystem, true, \
826 "Initialize java.lang.System - turn off for individual " \
827 "method debugging") \
828 \
829 develop(bool, InitializeJavaLangString, true, \
830 "Initialize java.lang.String - turn off for individual " \
831 "method debugging") \
832 \
833 develop(bool, InitializeJavaLangExceptionsErrors, true, \
834 "Initialize various error and exception classes - turn off for " \
835 "individual method debugging") \
836 \
837 product(bool, RegisterFinalizersAtInit, true, \
838 "Register finalizable objects at end of Object.<init> or " \
839 "after allocation") \
840 \
841 develop(bool, RegisterReferences, true, \
842 "Tells whether the VM should register soft/weak/final/phantom " \
843 "references") \
844 \
845 develop(bool, IgnoreRewrites, false, \
846 "Supress rewrites of bytecodes in the oopmap generator. " \
847 "This is unsafe!") \
848 \
849 develop(bool, PrintCodeCacheExtension, false, \
850 "Print extension of code cache") \
851 \
852 develop(bool, UsePrivilegedStack, true, \
853 "Enable the security JVM functions") \
854 \
855 develop(bool, IEEEPrecision, true, \
856 "Enables IEEE precision (for INTEL only)") \
857 \
858 develop(bool, ProtectionDomainVerification, true, \
859 "Verifies protection domain before resolution in system " \
860 "dictionary") \
861 \
862 product(bool, ClassUnloading, true, \
863 "Do unloading of classes") \
864 \
865 diagnostic(bool, LinkWellKnownClasses, false, \
866 "Resolve a well known class as soon as its name is seen") \
867 \
868 develop(bool, DisableStartThread, false, \
869 "Disable starting of additional Java threads " \
870 "(for debugging only)") \
871 \
872 develop(bool, MemProfiling, false, \
873 "Write memory usage profiling to log file") \
874 \
875 notproduct(bool, PrintSystemDictionaryAtExit, false, \
876 "Prints the system dictionary at exit") \
877 \
878 diagnostic(bool, UnsyncloadClass, false, \
879 "Unstable: VM calls loadClass unsynchronized. Custom " \
880 "class loader must call VM synchronized for findClass " \
881 "and defineClass.") \
882 \
883 product(bool, AlwaysLockClassLoader, false, \
884 "Require the VM to acquire the class loader lock before calling " \
885 "loadClass() even for class loaders registering " \
886 "as parallel capable") \
887 \
888 product(bool, AllowParallelDefineClass, false, \
889 "Allow parallel defineClass requests for class loaders " \
890 "registering as parallel capable") \
891 \
892 product(bool, MustCallLoadClassInternal, false, \
893 "Call loadClassInternal() rather than loadClass()") \
894 \
895 product_pd(bool, DontYieldALot, \
896 "Throw away obvious excess yield calls (for SOLARIS only)") \
897 \
898 product_pd(bool, ConvertSleepToYield, \
899 "Converts sleep(0) to thread yield " \
900 "(may be off for SOLARIS to improve GUI)") \
901 \
902 product(bool, ConvertYieldToSleep, false, \
903 "Converts yield to a sleep of MinSleepInterval to simulate Win32 "\
904 "behavior (SOLARIS only)") \
905 \
906 product(bool, UseBoundThreads, true, \
907 "Bind user level threads to kernel threads (for SOLARIS only)") \
908 \
909 develop(bool, UseDetachedThreads, true, \
910 "Use detached threads that are recycled upon termination " \
911 "(for SOLARIS only)") \
912 \
913 product(bool, UseLWPSynchronization, true, \
914 "Use LWP-based instead of libthread-based synchronization " \
915 "(SPARC only)") \
916 \
917 product(ccstr, SyncKnobs, NULL, \
918 "(Unstable) Various monitor synchronization tunables") \
919 \
920 product(intx, EmitSync, 0, \
921 "(Unsafe,Unstable) " \
922 " Controls emission of inline sync fast-path code") \
923 \
924 product(intx, AlwaysInflate, 0, "(Unstable) Force inflation") \
925 \
926 product(intx, MonitorBound, 0, "Bound Monitor population") \
927 \
928 product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \
929 \
930 product(intx, Atomics, 0, \
931 "(Unsafe,Unstable) Diagnostic - Controls emission of atomics") \
932 \
933 product(intx, FenceInstruction, 0, \
934 "(Unsafe,Unstable) Experimental") \
935 \
936 product(intx, SyncFlags, 0, "(Unsafe,Unstable) Experimental Sync flags" ) \
937 \
938 product(intx, SyncVerbose, 0, "(Unstable)" ) \
939 \
940 product(intx, ClearFPUAtPark, 0, "(Unsafe,Unstable)" ) \
941 \
942 product(intx, hashCode, 0, \
943 "(Unstable) select hashCode generation algorithm" ) \
944 \
945 product(intx, WorkAroundNPTLTimedWaitHang, 1, \
946 "(Unstable, Linux-specific)" \
947 " avoid NPTL-FUTEX hang pthread_cond_timedwait" ) \
948 \
949 product(bool, FilterSpuriousWakeups, true, \
950 "Prevent spurious or premature wakeups from object.wait " \
951 "(Solaris only)") \
952 \
953 product(intx, NativeMonitorTimeout, -1, "(Unstable)" ) \
954 product(intx, NativeMonitorFlags, 0, "(Unstable)" ) \
955 product(intx, NativeMonitorSpinLimit, 20, "(Unstable)" ) \
956 \
957 develop(bool, UsePthreads, false, \
958 "Use pthread-based instead of libthread-based synchronization " \
959 "(SPARC only)") \
960 \
961 product(bool, AdjustConcurrency, false, \
962 "call thr_setconcurrency at thread create time to avoid " \
963 "LWP starvation on MP systems (For Solaris Only)") \
964 \
965 develop(bool, UpdateHotSpotCompilerFileOnError, true, \
966 "Should the system attempt to update the compiler file when " \
967 "an error occurs?") \
968 \
969 product(bool, ReduceSignalUsage, false, \
970 "Reduce the use of OS signals in Java and/or the VM") \
971 \
972 notproduct(bool, ValidateMarkSweep, false, \
973 "Do extra validation during MarkSweep collection") \
974 \
975 notproduct(bool, RecordMarkSweepCompaction, false, \
976 "Enable GC-to-GC recording and querying of compaction during " \
977 "MarkSweep") \
978 \
979 develop_pd(bool, ShareVtableStubs, \
980 "Share vtable stubs (smaller code but worse branch prediction") \
981 \
982 develop(bool, LoadLineNumberTables, true, \
983 "Tells whether the class file parser loads line number tables") \
984 \
985 develop(bool, LoadLocalVariableTables, true, \
986 "Tells whether the class file parser loads local variable tables")\
987 \
988 develop(bool, LoadLocalVariableTypeTables, true, \
989 "Tells whether the class file parser loads local variable type tables")\
990 \
991 product(bool, AllowUserSignalHandlers, false, \
992 "Do not complain if the application installs signal handlers " \
993 "(Solaris & Linux only)") \
994 \
995 product(bool, UseSignalChaining, true, \
996 "Use signal-chaining to invoke signal handlers installed " \
997 "by the application (Solaris & Linux only)") \
998 \
999 product(bool, UseAltSigs, false, \
1000 "Use alternate signals instead of SIGUSR1 & SIGUSR2 for VM " \
1001 "internal signals (Solaris only)") \
1002 \
1003 product(bool, UseSpinning, false, \
1004 "Use spinning in monitor inflation and before entry") \
1005 \
1006 product(bool, PreSpinYield, false, \
1007 "Yield before inner spinning loop") \
1008 \
1009 product(bool, PostSpinYield, true, \
1010 "Yield after inner spinning loop") \
1011 \
1012 product(bool, AllowJNIEnvProxy, false, \
1013 "Allow JNIEnv proxies for jdbx") \
1014 \
1015 product(bool, JNIDetachReleasesMonitors, true, \
1016 "JNI DetachCurrentThread releases monitors owned by thread") \
1017 \
1018 product(bool, RestoreMXCSROnJNICalls, false, \
1019 "Restore MXCSR when returning from JNI calls") \
1020 \
1021 product(bool, CheckJNICalls, false, \
1022 "Verify all arguments to JNI calls") \
1023 \
1024 product(bool, UseFastJNIAccessors, true, \
1025 "Use optimized versions of Get<Primitive>Field") \
1026 \
1027 product(bool, EagerXrunInit, false, \
1028 "Eagerly initialize -Xrun libraries; allows startup profiling, " \
1029 " but not all -Xrun libraries may support the state of the VM at this time") \
1030 \
1031 product(bool, PreserveAllAnnotations, false, \
1032 "Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations") \
1033 \
1034 develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \
1035 "Number of OutOfMemoryErrors preallocated with backtrace") \
1036 \
1037 product(bool, LazyBootClassLoader, true, \
1038 "Enable/disable lazy opening of boot class path entries") \
1039 \
1040 diagnostic(bool, UseIncDec, true, \
1041 "Use INC, DEC instructions on x86") \
1042 \
1043 product(bool, UseNewLongLShift, false, \
1044 "Use optimized bitwise shift left") \
1045 \
1046 product(bool, UseStoreImmI16, true, \
1047 "Use store immediate 16-bits value instruction on x86") \
1048 \
1049 product(bool, UseAddressNop, false, \
1050 "Use '0F 1F [addr]' NOP instructions on x86 cpus") \
1051 \
1052 product(bool, UseXmmLoadAndClearUpper, true, \
1053 "Load low part of XMM register and clear upper part") \
1054 \
1055 product(bool, UseXmmRegToRegMoveAll, false, \
1056 "Copy all XMM register bits when moving value between registers") \
1057 \
1058 product(bool, UseXmmI2D, false, \
1059 "Use SSE2 CVTDQ2PD instruction to convert Integer to Double") \
1060 \
1061 product(bool, UseXmmI2F, false, \
1062 "Use SSE2 CVTDQ2PS instruction to convert Integer to Float") \
1063 \
1064 product(bool, UseXMMForArrayCopy, false, \
1065 "Use SSE2 MOVQ instruction for Arraycopy") \
1066 \
1067 product(bool, UseUnalignedLoadStores, false, \
1068 "Use SSE2 MOVDQU instruction for Arraycopy") \
1069 \
1070 product(intx, FieldsAllocationStyle, 1, \
1071 "0 - type based with oops first, 1 - with oops last, " \
1072 "2 - oops in super and sub classes are together") \
1073 \
1074 product(bool, CompactFields, true, \
1075 "Allocate nonstatic fields in gaps between previous fields") \
1076 \
1077 notproduct(bool, PrintCompactFieldsSavings, false, \
1078 "Print how many words were saved with CompactFields") \
1079 \
1080 product(bool, UseBiasedLocking, true, \
1081 "Enable biased locking in JVM") \
1082 \
1083 product(intx, BiasedLockingStartupDelay, 4000, \
1084 "Number of milliseconds to wait before enabling biased locking") \
1085 \
1086 diagnostic(bool, PrintBiasedLockingStatistics, false, \
1087 "Print statistics of biased locking in JVM") \
1088 \
1089 product(intx, BiasedLockingBulkRebiasThreshold, 20, \
1090 "Threshold of number of revocations per type to try to " \
1091 "rebias all objects in the heap of that type") \
1092 \
1093 product(intx, BiasedLockingBulkRevokeThreshold, 40, \
1094 "Threshold of number of revocations per type to permanently " \
1095 "revoke biases of all objects in the heap of that type") \
1096 \
1097 product(intx, BiasedLockingDecayTime, 25000, \
1098 "Decay time (in milliseconds) to re-enable bulk rebiasing of a " \
1099 "type after previous bulk rebias") \
1100 \
1101 /* tracing */ \
1102 \
1103 notproduct(bool, TraceRuntimeCalls, false, \
1104 "Trace run-time calls") \
1105 \
1106 develop(bool, TraceJNICalls, false, \
1107 "Trace JNI calls") \
1108 \
1109 notproduct(bool, TraceJVMCalls, false, \
1110 "Trace JVM calls") \
1111 \
1112 product(ccstr, TraceJVMTI, NULL, \
1113 "Trace flags for JVMTI functions and events") \
1114 \
1115 product(bool, ForceFullGCJVMTIEpilogues, false, \
1116 "Force 'Full GC' was done semantics for JVMTI GC epilogues") \
1117 \
1118 /* This option can change an EMCP method into an obsolete method. */ \
1119 /* This can affect tests that except specific methods to be EMCP. */ \
1120 /* This option should be used with caution. */ \
1121 product(bool, StressLdcRewrite, false, \
1122 "Force ldc -> ldc_w rewrite during RedefineClasses") \
1123 \
1124 product(intx, TraceRedefineClasses, 0, \
1125 "Trace level for JVMTI RedefineClasses") \
1126 \
1127 develop(bool, StressMethodComparator, false, \
1128 "run the MethodComparator on all loaded methods") \
1129 \
1130 /* change to false by default sometime after Mustang */ \
1131 product(bool, VerifyMergedCPBytecodes, true, \
1132 "Verify bytecodes after RedefineClasses constant pool merging") \
1133 \
1134 develop(bool, TraceJNIHandleAllocation, false, \
1135 "Trace allocation/deallocation of JNI handle blocks") \
1136 \
1137 develop(bool, TraceThreadEvents, false, \
1138 "Trace all thread events") \
1139 \
1140 develop(bool, TraceBytecodes, false, \
1141 "Trace bytecode execution") \
1142 \
1143 develop(bool, TraceClassInitialization, false, \
1144 "Trace class initialization") \
1145 \
1146 develop(bool, TraceExceptions, false, \
1147 "Trace exceptions") \
1148 \
1149 develop(bool, TraceICs, false, \
1150 "Trace inline cache changes") \
1151 \
1152 notproduct(bool, TraceInvocationCounterOverflow, false, \
1153 "Trace method invocation counter overflow") \
1154 \
1155 develop(bool, TraceInlineCacheClearing, false, \
1156 "Trace clearing of inline caches in nmethods") \
1157 \
1158 develop(bool, TraceDependencies, false, \
1159 "Trace dependencies") \
1160 \
1161 develop(bool, VerifyDependencies, trueInDebug, \
1162 "Exercise and verify the compilation dependency mechanism") \
1163 \
1164 develop(bool, TraceNewOopMapGeneration, false, \
1165 "Trace OopMapGeneration") \
1166 \
1167 develop(bool, TraceNewOopMapGenerationDetailed, false, \
1168 "Trace OopMapGeneration: print detailed cell states") \
1169 \
1170 develop(bool, TimeOopMap, false, \
1171 "Time calls to GenerateOopMap::compute_map() in sum") \
1172 \
1173 develop(bool, TimeOopMap2, false, \
1174 "Time calls to GenerateOopMap::compute_map() individually") \
1175 \
1176 develop(bool, TraceMonitorMismatch, false, \
1177 "Trace monitor matching failures during OopMapGeneration") \
1178 \
1179 develop(bool, TraceOopMapRewrites, false, \
1180 "Trace rewritting of method oops during oop map generation") \
1181 \
1182 develop(bool, TraceSafepoint, false, \
1183 "Trace safepoint operations") \
1184 \
1185 develop(bool, TraceICBuffer, false, \
1186 "Trace usage of IC buffer") \
1187 \
1188 develop(bool, TraceCompiledIC, false, \
1189 "Trace changes of compiled IC") \
1190 \
1191 notproduct(bool, TraceZapDeadLocals, false, \
1192 "Trace zapping dead locals") \
1193 \
1194 develop(bool, TraceStartupTime, false, \
1195 "Trace setup time") \
1196 \
1197 develop(bool, TraceHPI, false, \
1198 "Trace Host Porting Interface (HPI)") \
1199 \
1200 product(ccstr, HPILibPath, NULL, \
1201 "Specify alternate path to HPI library") \
1202 \
1203 develop(bool, TraceProtectionDomainVerification, false, \
1204 "Trace protection domain verifcation") \
1205 \
1206 develop(bool, TraceClearedExceptions, false, \
1207 "Prints when an exception is forcibly cleared") \
1208 \
1209 product(bool, TraceClassResolution, false, \
1210 "Trace all constant pool resolutions (for debugging)") \
1211 \
1212 product(bool, TraceBiasedLocking, false, \
1213 "Trace biased locking in JVM") \
1214 \
1215 product(bool, TraceMonitorInflation, false, \
1216 "Trace monitor inflation in JVM") \
1217 \
1218 /* assembler */ \
1219 product(bool, Use486InstrsOnly, false, \
1220 "Use 80486 Compliant instruction subset") \
1221 \
1222 /* gc */ \
1223 \
1224 product(bool, UseSerialGC, false, \
1225 "Use the serial garbage collector") \
1226 \
1227 product(bool, UseG1GC, false, \
1228 "Use the Garbage-First garbage collector") \
1229 \
1230 product(bool, UseParallelGC, false, \
1231 "Use the Parallel Scavenge garbage collector") \
1232 \
1233 product(bool, UseParallelOldGC, false, \
1234 "Use the Parallel Old garbage collector") \
1235 \
1236 product(bool, UseParallelOldGCCompacting, true, \
1237 "In the Parallel Old garbage collector use parallel compaction") \
1238 \
1239 product(bool, UseParallelDensePrefixUpdate, true, \
1240 "In the Parallel Old garbage collector use parallel dense" \
1241 " prefix update") \
1242 \
1243 product(uintx, HeapMaximumCompactionInterval, 20, \
1244 "How often should we maximally compact the heap (not allowing " \
1245 "any dead space)") \
1246 \
1247 product(uintx, HeapFirstMaximumCompactionCount, 3, \
1248 "The collection count for the first maximum compaction") \
1249 \
1250 product(bool, UseMaximumCompactionOnSystemGC, true, \
1251 "In the Parallel Old garbage collector maximum compaction for " \
1252 "a system GC") \
1253 \
1254 product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
1255 "The mean used by the par compact dead wood" \
1256 "limiter (a number between 0-100).") \
1257 \
1258 product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
1259 "The standard deviation used by the par compact dead wood" \
1260 "limiter (a number between 0-100).") \
1261 \
1262 product(bool, UseParallelOldGCDensePrefix, true, \
1263 "Use a dense prefix with the Parallel Old garbage collector") \
1264 \
1265 product(uintx, ParallelGCThreads, 0, \
1266 "Number of parallel threads parallel gc will use") \
1267 \
1268 develop(bool, ParallelOldGCSplitALot, false, \
1269 "Provoke splitting (copying data from a young gen space to" \
1270 "multiple destination spaces)") \
1271 \
1272 develop(uintx, ParallelOldGCSplitInterval, 3, \
1273 "How often to provoke splitting a young gen space") \
1274 \
1275 develop(bool, TraceRegionTasksQueuing, false, \
1276 "Trace the queuing of the region tasks") \
1277 \
1278 product(uintx, ConcGCThreads, 0, \
1279 "Number of threads concurrent gc will use") \
1280 \
1281 product(uintx, YoungPLABSize, 4096, \
1282 "Size of young gen promotion labs (in HeapWords)") \
1283 \
1284 product(uintx, OldPLABSize, 1024, \
1285 "Size of old gen promotion labs (in HeapWords)") \
1286 \
1287 product(uintx, GCTaskTimeStampEntries, 200, \
1288 "Number of time stamp entries per gc worker thread") \
1289 \
1290 product(bool, AlwaysTenure, false, \
1291 "Always tenure objects in eden. (ParallelGC only)") \
1292 \
1293 product(bool, NeverTenure, false, \
1294 "Never tenure objects in eden, May tenure on overflow " \
1295 "(ParallelGC only)") \
1296 \
1297 product(bool, ScavengeBeforeFullGC, true, \
1298 "Scavenge youngest generation before each full GC, " \
1299 "used with UseParallelGC") \
1300 \
1301 develop(bool, ScavengeWithObjectsInToSpace, false, \
1302 "Allow scavenges to occur when to_space contains objects.") \
1303 \
1304 product(bool, UseConcMarkSweepGC, false, \
1305 "Use Concurrent Mark-Sweep GC in the old generation") \
1306 \
1307 product(bool, ExplicitGCInvokesConcurrent, false, \
1308 "A System.gc() request invokes a concurrent collection;" \
1309 " (effective only when UseConcMarkSweepGC)") \
1310 \
1311 product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
1312 "A System.gc() request invokes a concurrent collection and " \
1313 "also unloads classes during such a concurrent gc cycle " \
1314 "(effective only when UseConcMarkSweepGC)") \
1315 \
1316 product(bool, GCLockerInvokesConcurrent, false, \
1317 "The exit of a JNI CS necessitating a scavenge also" \
1318 " kicks off a bkgrd concurrent collection") \
1319 \
1320 develop(bool, UseCMSAdaptiveFreeLists, true, \
1321 "Use Adaptive Free Lists in the CMS generation") \
1322 \
1323 develop(bool, UseAsyncConcMarkSweepGC, true, \
1324 "Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
1325 \
1326 develop(bool, RotateCMSCollectionTypes, false, \
1327 "Rotate the CMS collections among concurrent and STW") \
1328 \
1329 product(bool, UseCMSBestFit, true, \
1330 "Use CMS best fit allocation strategy") \
1331 \
1332 product(bool, UseCMSCollectionPassing, true, \
1333 "Use passing of collection from background to foreground") \
1334 \
1335 product(bool, UseParNewGC, false, \
1336 "Use parallel threads in the new generation.") \
1337 \
1338 product(bool, ParallelGCVerbose, false, \
1339 "Verbose output for parallel GC.") \
1340 \
1341 product(intx, ParallelGCBufferWastePct, 10, \
1342 "wasted fraction of parallel allocation buffer.") \
1343 \
1344 product(bool, ParallelGCRetainPLAB, true, \
1345 "Retain parallel allocation buffers across scavenges.") \
1346 \
1347 product(intx, TargetPLABWastePct, 10, \
1348 "target wasted space in last buffer as pct of overall allocation")\
1349 \
1350 product(uintx, PLABWeight, 75, \
1351 "Percentage (0-100) used to weight the current sample when" \
1352 "computing exponentially decaying average for ResizePLAB.") \
1353 \
1354 product(bool, ResizePLAB, true, \
1355 "Dynamically resize (survivor space) promotion labs") \
1356 \
1357 product(bool, PrintPLAB, false, \
1358 "Print (survivor space) promotion labs sizing decisions") \
1359 \
1360 product(intx, ParGCArrayScanChunk, 50, \
1361 "Scan a subset and push remainder, if array is bigger than this") \
1362 \
1363 product(bool, ParGCUseLocalOverflow, false, \
1364 "Instead of a global overflow list, use local overflow stacks") \
1365 \
1366 product(bool, ParGCTrimOverflow, true, \
1367 "Eagerly trim the local overflow lists (when ParGCUseLocalOverflow") \
1368 \
1369 notproduct(bool, ParGCWorkQueueOverflowALot, false, \
1370 "Whether we should simulate work queue overflow in ParNew") \
1371 \
1372 notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
1373 "An `interval' counter that determines how frequently " \
1374 "we simulate overflow; a smaller number increases frequency") \
1375 \
1376 product(uintx, ParGCDesiredObjsFromOverflowList, 20, \
1377 "The desired number of objects to claim from the overflow list") \
1378 \
1379 product(uintx, CMSParPromoteBlocksToClaim, 16, \
1380 "Number of blocks to attempt to claim when refilling CMS LAB for "\
1381 "parallel GC.") \
1382 \
1383 product(uintx, OldPLABWeight, 50, \
1384 "Percentage (0-100) used to weight the current sample when" \
1385 "computing exponentially decaying average for resizing CMSParPromoteBlocksToClaim.") \
1386 \
1387 product(bool, ResizeOldPLAB, true, \
1388 "Dynamically resize (old gen) promotion labs") \
1389 \
1390 product(bool, PrintOldPLAB, false, \
1391 "Print (old gen) promotion labs sizing decisions") \
1392 \
1393 product(uintx, CMSOldPLABMin, 16, \
1394 "Min size of CMS gen promotion lab caches per worker per blksize")\
1395 \
1396 product(uintx, CMSOldPLABMax, 1024, \
1397 "Max size of CMS gen promotion lab caches per worker per blksize")\
1398 \
1399 product(uintx, CMSOldPLABNumRefills, 4, \
1400 "Nominal number of refills of CMS gen promotion lab cache" \
1401 " per worker per block size") \
1402 \
1403 product(bool, CMSOldPLABResizeQuicker, false, \
1404 "Whether to react on-the-fly during a scavenge to a sudden" \
1405 " change in block demand rate") \
1406 \
1407 product(uintx, CMSOldPLABToleranceFactor, 4, \
1408 "The tolerance of the phase-change detector for on-the-fly" \
1409 " PLAB resizing during a scavenge") \
1410 \
1411 product(uintx, CMSOldPLABReactivityFactor, 2, \
1412 "The gain in the feedback loop for on-the-fly PLAB resizing" \
1413 " during a scavenge") \
1414 \
1415 product(uintx, CMSOldPLABReactivityCeiling, 10, \
1416 "The clamping of the gain in the feedback loop for on-the-fly" \
1417 " PLAB resizing during a scavenge") \
1418 \
1419 product(bool, AlwaysPreTouch, false, \
1420 "It forces all freshly committed pages to be pre-touched.") \
1421 \
1422 product(bool, CMSUseOldDefaults, false, \
1423 "A flag temporarily introduced to allow reverting to some " \
1424 "older default settings; older as of 6.0") \
1425 \
1426 product(intx, CMSYoungGenPerWorker, 16*M, \
1427 "The amount of young gen chosen by default per GC worker " \
1428 "thread available") \
1429 \
1430 product(bool, GCOverheadReporting, false, \
1431 "Enables the GC overhead reporting facility") \
1432 \
1433 product(intx, GCOverheadReportingPeriodMS, 100, \
1434 "Reporting period for conc GC overhead reporting, in ms ") \
1435 \
1436 product(bool, CMSIncrementalMode, false, \
1437 "Whether CMS GC should operate in \"incremental\" mode") \
1438 \
1439 product(uintx, CMSIncrementalDutyCycle, 10, \
1440 "CMS incremental mode duty cycle (a percentage, 0-100). If" \
1441 "CMSIncrementalPacing is enabled, then this is just the initial" \
1442 "value") \
1443 \
1444 product(bool, CMSIncrementalPacing, true, \
1445 "Whether the CMS incremental mode duty cycle should be " \
1446 "automatically adjusted") \
1447 \
1448 product(uintx, CMSIncrementalDutyCycleMin, 0, \
1449 "Lower bound on the duty cycle when CMSIncrementalPacing is " \
1450 "enabled (a percentage, 0-100)") \
1451 \
1452 product(uintx, CMSIncrementalSafetyFactor, 10, \
1453 "Percentage (0-100) used to add conservatism when computing the " \
1454 "duty cycle") \
1455 \
1456 product(uintx, CMSIncrementalOffset, 0, \
1457 "Percentage (0-100) by which the CMS incremental mode duty cycle" \
1458 " is shifted to the right within the period between young GCs") \
1459 \
1460 product(uintx, CMSExpAvgFactor, 50, \
1461 "Percentage (0-100) used to weight the current sample when" \
1462 "computing exponential averages for CMS statistics.") \
1463 \
1464 product(uintx, CMS_FLSWeight, 75, \
1465 "Percentage (0-100) used to weight the current sample when" \
1466 "computing exponentially decating averages for CMS FLS statistics.") \
1467 \
1468 product(uintx, CMS_FLSPadding, 1, \
1469 "The multiple of deviation from mean to use for buffering" \
1470 "against volatility in free list demand.") \
1471 \
1472 product(uintx, FLSCoalescePolicy, 2, \
1473 "CMS: Aggression level for coalescing, increasing from 0 to 4") \
1474 \
1475 product(bool, FLSAlwaysCoalesceLarge, false, \
1476 "CMS: Larger free blocks are always available for coalescing") \
1477 \
1478 product(double, FLSLargestBlockCoalesceProximity, 0.99, \
1479 "CMS: the smaller the percentage the greater the coalition force")\
1480 \
1481 product(double, CMSSmallCoalSurplusPercent, 1.05, \
1482 "CMS: the factor by which to inflate estimated demand of small" \
1483 " block sizes to prevent coalescing with an adjoining block") \
1484 \
1485 product(double, CMSLargeCoalSurplusPercent, 0.95, \
1486 "CMS: the factor by which to inflate estimated demand of large" \
1487 " block sizes to prevent coalescing with an adjoining block") \
1488 \
1489 product(double, CMSSmallSplitSurplusPercent, 1.10, \
1490 "CMS: the factor by which to inflate estimated demand of small" \
1491 " block sizes to prevent splitting to supply demand for smaller" \
1492 " blocks") \
1493 \
1494 product(double, CMSLargeSplitSurplusPercent, 1.00, \
1495 "CMS: the factor by which to inflate estimated demand of large" \
1496 " block sizes to prevent splitting to supply demand for smaller" \
1497 " blocks") \
1498 \
1499 product(bool, CMSExtrapolateSweep, false, \
1500 "CMS: cushion for block demand during sweep") \
1501 \
1502 product(uintx, CMS_SweepWeight, 75, \
1503 "Percentage (0-100) used to weight the current sample when " \
1504 "computing exponentially decaying average for inter-sweep " \
1505 "duration") \
1506 \
1507 product(uintx, CMS_SweepPadding, 1, \
1508 "The multiple of deviation from mean to use for buffering " \
1509 "against volatility in inter-sweep duration.") \
1510 \
1511 product(uintx, CMS_SweepTimerThresholdMillis, 10, \
1512 "Skip block flux-rate sampling for an epoch unless inter-sweep " \
1513 "duration exceeds this threhold in milliseconds") \
1514 \
1515 develop(bool, CMSTraceIncrementalMode, false, \
1516 "Trace CMS incremental mode") \
1517 \
1518 develop(bool, CMSTraceIncrementalPacing, false, \
1519 "Trace CMS incremental mode pacing computation") \
1520 \
1521 develop(bool, CMSTraceThreadState, false, \
1522 "Trace the CMS thread state (enable the trace_state() method)") \
1523 \
1524 product(bool, CMSClassUnloadingEnabled, false, \
1525 "Whether class unloading enabled when using CMS GC") \
1526 \
1527 product(uintx, CMSClassUnloadingMaxInterval, 0, \
1528 "When CMS class unloading is enabled, the maximum CMS cycle count"\
1529 " for which classes may not be unloaded") \
1530 \
1531 product(bool, CMSCompactWhenClearAllSoftRefs, true, \
1532 "Compact when asked to collect CMS gen with clear_all_soft_refs") \
1533 \
1534 product(bool, UseCMSCompactAtFullCollection, true, \
1535 "Use mark sweep compact at full collections") \
1536 \
1537 product(uintx, CMSFullGCsBeforeCompaction, 0, \
1538 "Number of CMS full collection done before compaction if > 0") \
1539 \
1540 develop(intx, CMSDictionaryChoice, 0, \
1541 "Use BinaryTreeDictionary as default in the CMS generation") \
1542 \
1543 product(uintx, CMSIndexedFreeListReplenish, 4, \
1544 "Replenish and indexed free list with this number of chunks") \
1545 \
1546 product(bool, CMSReplenishIntermediate, true, \
1547 "Replenish all intermediate free-list caches") \
1548 \
1549 product(bool, CMSSplitIndexedFreeListBlocks, true, \
1550 "When satisfying batched demand, splot blocks from the " \
1551 "IndexedFreeList whose size is a multiple of requested size") \
1552 \
1553 product(bool, CMSLoopWarn, false, \
1554 "Warn in case of excessive CMS looping") \
1555 \
1556 develop(bool, CMSOverflowEarlyRestoration, false, \
1557 "Whether preserved marks should be restored early") \
1558 \
1559 product(uintx, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
1560 "Size of marking stack") \
1561 \
1562 product(uintx, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
1563 "Max size of marking stack") \
1564 \
1565 notproduct(bool, CMSMarkStackOverflowALot, false, \
1566 "Whether we should simulate frequent marking stack / work queue" \
1567 " overflow") \
1568 \
1569 notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
1570 "An `interval' counter that determines how frequently" \
1571 " we simulate overflow; a smaller number increases frequency") \
1572 \
1573 product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
1574 "(Temporary, subject to experimentation)" \
1575 "Maximum number of abortable preclean iterations, if > 0") \
1576 \
1577 product(intx, CMSMaxAbortablePrecleanTime, 5000, \
1578 "(Temporary, subject to experimentation)" \
1579 "Maximum time in abortable preclean in ms") \
1580 \
1581 product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
1582 "(Temporary, subject to experimentation)" \
1583 "Nominal minimum work per abortable preclean iteration") \
1584 \
1585 product(intx, CMSAbortablePrecleanWaitMillis, 100, \
1586 "(Temporary, subject to experimentation)" \
1587 " Time that we sleep between iterations when not given" \
1588 " enough work per iteration") \
1589 \
1590 product(uintx, CMSRescanMultiple, 32, \
1591 "Size (in cards) of CMS parallel rescan task") \
1592 \
1593 product(uintx, CMSConcMarkMultiple, 32, \
1594 "Size (in cards) of CMS concurrent MT marking task") \
1595 \
1596 product(uintx, CMSRevisitStackSize, 1*M, \
1597 "Size of CMS KlassKlass revisit stack") \
1598 \
1599 product(bool, CMSAbortSemantics, false, \
1600 "Whether abort-on-overflow semantics is implemented") \
1601 \
1602 product(bool, CMSParallelRemarkEnabled, true, \
1603 "Whether parallel remark enabled (only if ParNewGC)") \
1604 \
1605 product(bool, CMSParallelSurvivorRemarkEnabled, true, \
1606 "Whether parallel remark of survivor space" \
1607 " enabled (effective only if CMSParallelRemarkEnabled)") \
1608 \
1609 product(bool, CMSPLABRecordAlways, true, \
1610 "Whether to always record survivor space PLAB bdries" \
1611 " (effective only if CMSParallelSurvivorRemarkEnabled)") \
1612 \
1613 product(bool, CMSConcurrentMTEnabled, true, \
1614 "Whether multi-threaded concurrent work enabled (if ParNewGC)") \
1615 \
1616 product(bool, CMSPermGenPrecleaningEnabled, true, \
1617 "Whether concurrent precleaning enabled in perm gen" \
1618 " (effective only when CMSPrecleaningEnabled is true)") \
1619 \
1620 product(bool, CMSPrecleaningEnabled, true, \
1621 "Whether concurrent precleaning enabled") \
1622 \
1623 product(uintx, CMSPrecleanIter, 3, \
1624 "Maximum number of precleaning iteration passes") \
1625 \
1626 product(uintx, CMSPrecleanNumerator, 2, \
1627 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
1628 " ratio") \
1629 \
1630 product(uintx, CMSPrecleanDenominator, 3, \
1631 "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
1632 " ratio") \
1633 \
1634 product(bool, CMSPrecleanRefLists1, true, \
1635 "Preclean ref lists during (initial) preclean phase") \
1636 \
1637 product(bool, CMSPrecleanRefLists2, false, \
1638 "Preclean ref lists during abortable preclean phase") \
1639 \
1640 product(bool, CMSPrecleanSurvivors1, false, \
1641 "Preclean survivors during (initial) preclean phase") \
1642 \
1643 product(bool, CMSPrecleanSurvivors2, true, \
1644 "Preclean survivors during abortable preclean phase") \
1645 \
1646 product(uintx, CMSPrecleanThreshold, 1000, \
1647 "Don't re-iterate if #dirty cards less than this") \
1648 \
1649 product(bool, CMSCleanOnEnter, true, \
1650 "Clean-on-enter optimization for reducing number of dirty cards") \
1651 \
1652 product(uintx, CMSRemarkVerifyVariant, 1, \
1653 "Choose variant (1,2) of verification following remark") \
1654 \
1655 product(uintx, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
1656 "If Eden used is below this value, don't try to schedule remark") \
1657 \
1658 product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
1659 "The Eden occupancy % at which to try and schedule remark pause") \
1660 \
1661 product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
1662 "Start sampling Eden top at least before yg occupancy reaches" \
1663 " 1/<ratio> of the size at which we plan to schedule remark") \
1664 \
1665 product(uintx, CMSSamplingGrain, 16*K, \
1666 "The minimum distance between eden samples for CMS (see above)") \
1667 \
1668 product(bool, CMSScavengeBeforeRemark, false, \
1669 "Attempt scavenge before the CMS remark step") \
1670 \
1671 develop(bool, CMSTraceSweeper, false, \
1672 "Trace some actions of the CMS sweeper") \
1673 \
1674 product(uintx, CMSWorkQueueDrainThreshold, 10, \
1675 "Don't drain below this size per parallel worker/thief") \
1676 \
1677 product(intx, CMSWaitDuration, 2000, \
1678 "Time in milliseconds that CMS thread waits for young GC") \
1679 \
1680 product(bool, CMSYield, true, \
1681 "Yield between steps of concurrent mark & sweep") \
1682 \
1683 product(uintx, CMSBitMapYieldQuantum, 10*M, \
1684 "Bitmap operations should process at most this many bits" \
1685 "between yields") \
1686 \
1687 product(bool, CMSDumpAtPromotionFailure, false, \
1688 "Dump useful information about the state of the CMS old " \
1689 " generation upon a promotion failure.") \
1690 \
1691 product(bool, CMSPrintChunksInDump, false, \
1692 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1693 " more detailed information about the free chunks.") \
1694 \
1695 product(bool, CMSPrintObjectsInDump, false, \
1696 "In a dump enabled by CMSDumpAtPromotionFailure, include " \
1697 " more detailed information about the allocated objects.") \
1698 \
1699 diagnostic(bool, FLSVerifyAllHeapReferences, false, \
1700 "Verify that all refs across the FLS boundary " \
1701 " are to valid objects") \
1702 \
1703 diagnostic(bool, FLSVerifyLists, false, \
1704 "Do lots of (expensive) FreeListSpace verification") \
1705 \
1706 diagnostic(bool, FLSVerifyIndexTable, false, \
1707 "Do lots of (expensive) FLS index table verification") \
1708 \
1709 develop(bool, FLSVerifyDictionary, false, \
1710 "Do lots of (expensive) FLS dictionary verification") \
1711 \
1712 develop(bool, VerifyBlockOffsetArray, false, \
1713 "Do (expensive!) block offset array verification") \
1714 \
1715 product(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
1716 "Maintain _unallocated_block in BlockOffsetArray" \
1717 " (currently applicable only to CMS collector)") \
1718 \
1719 develop(bool, TraceCMSState, false, \
1720 "Trace the state of the CMS collection") \
1721 \
1722 product(intx, RefDiscoveryPolicy, 0, \
1723 "Whether reference-based(0) or referent-based(1)") \
1724 \
1725 product(bool, ParallelRefProcEnabled, false, \
1726 "Enable parallel reference processing whenever possible") \
1727 \
1728 product(bool, ParallelRefProcBalancingEnabled, true, \
1729 "Enable balancing of reference processing queues") \
1730 \
1731 product(intx, CMSTriggerRatio, 80, \
1732 "Percentage of MinHeapFreeRatio in CMS generation that is " \
1733 "allocated before a CMS collection cycle commences") \
1734 \
1735 product(intx, CMSTriggerPermRatio, 80, \
1736 "Percentage of MinHeapFreeRatio in the CMS perm generation that " \
1737 "is allocated before a CMS collection cycle commences, that " \
1738 "also collects the perm generation") \
1739 \
1740 product(uintx, CMSBootstrapOccupancy, 50, \
1741 "Percentage CMS generation occupancy at which to " \
1742 "initiate CMS collection for bootstrapping collection stats") \
1743 \
1744 product(intx, CMSInitiatingOccupancyFraction, -1, \
1745 "Percentage CMS generation occupancy to start a CMS collection " \
1746 "cycle. A negative value means that CMSTriggerRatio is used") \
1747 \
1748 product(uintx, InitiatingHeapOccupancyPercent, 45, \
1749 "Percentage of the (entire) heap occupancy to start a " \
1750 "concurrent GC cycle. It us used by GCs that trigger a " \
1751 "concurrent GC cycle based on the occupancy of the entire heap, " \
1752 "not just one of the generations (e.g., G1). A value of 0 " \
1753 "denotes 'do constant GC cycles'.") \
1754 \
1755 product(intx, CMSInitiatingPermOccupancyFraction, -1, \
1756 "Percentage CMS perm generation occupancy to start a " \
1757 "CMScollection cycle. A negative value means that " \
1758 "CMSTriggerPermRatio is used") \
1759 \
1760 product(bool, UseCMSInitiatingOccupancyOnly, false, \
1761 "Only use occupancy as a crierion for starting a CMS collection") \
1762 \
1763 product(intx, CMSIsTooFullPercentage, 98, \
1764 "An absolute ceiling above which CMS will always consider the " \
1765 "perm gen ripe for collection") \
1766 \
1767 develop(bool, CMSTestInFreeList, false, \
1768 "Check if the coalesced range is already in the " \
1769 "free lists as claimed") \
1770 \
1771 notproduct(bool, CMSVerifyReturnedBytes, false, \
1772 "Check that all the garbage collected was returned to the " \
1773 "free lists.") \
1774 \
1775 notproduct(bool, ScavengeALot, false, \
1776 "Force scavenge at every Nth exit from the runtime system " \
1777 "(N=ScavengeALotInterval)") \
1778 \
1779 develop(bool, FullGCALot, false, \
1780 "Force full gc at every Nth exit from the runtime system " \
1781 "(N=FullGCALotInterval)") \
1782 \
1783 notproduct(bool, GCALotAtAllSafepoints, false, \
1784 "Enforce ScavengeALot/GCALot at all potential safepoints") \
1785 \
1786 product(bool, HandlePromotionFailure, true, \
1787 "The youngest generation collection does not require " \
1788 "a guarantee of full promotion of all live objects.") \
1789 \
1790 product(bool, PrintPromotionFailure, false, \
1791 "Print additional diagnostic information following " \
1792 " promotion failure") \
1793 \
1794 notproduct(bool, PromotionFailureALot, false, \
1795 "Use promotion failure handling on every youngest generation " \
1796 "collection") \
1797 \
1798 develop(uintx, PromotionFailureALotCount, 1000, \
1799 "Number of promotion failures occurring at ParGCAllocBuffer" \
1800 "refill attempts (ParNew) or promotion attempts " \
1801 "(other young collectors) ") \
1802 \
1803 develop(uintx, PromotionFailureALotInterval, 5, \
1804 "Total collections between promotion failures alot") \
1805 \
1806 develop(intx, WorkStealingSleepMillis, 1, \
1807 "Sleep time when sleep is used for yields") \
1808 \
1809 develop(uintx, WorkStealingYieldsBeforeSleep, 1000, \
1810 "Number of yields before a sleep is done during workstealing") \
1811 \
1812 develop(uintx, WorkStealingHardSpins, 4096, \
1813 "Number of iterations in a spin loop between checks on " \
1814 "time out of hard spin") \
1815 \
1816 develop(uintx, WorkStealingSpinToYieldRatio, 10, \
1817 "Ratio of hard spins to calls to yield") \
1818 \
1819 product(uintx, PreserveMarkStackSize, 1024, \
1820 "Size for stack used in promotion failure handling") \
1821 \
1822 develop(uintx, ObjArrayMarkingStride, 512, \
1823 "Number of ObjArray elements to push onto the marking stack" \
1824 "before pushing a continuation entry") \
1825 \
1826 product_pd(bool, UseTLAB, "Use thread-local object allocation") \
1827 \
1828 product_pd(bool, ResizeTLAB, \
1829 "Dynamically resize tlab size for threads") \
1830 \
1831 product(bool, ZeroTLAB, false, \
1832 "Zero out the newly created TLAB") \
1833 \
1834 product(bool, FastTLABRefill, true, \
1835 "Use fast TLAB refill code") \
1836 \
1837 product(bool, PrintTLAB, false, \
1838 "Print various TLAB related information") \
1839 \
1840 product(bool, TLABStats, true, \
1841 "Print various TLAB related information") \
1842 \
1843 product(bool, PrintRevisitStats, false, \
1844 "Print revisit (klass and MDO) stack related information") \
1845 \
1846 product_pd(bool, NeverActAsServerClassMachine, \
1847 "Never act like a server-class machine") \
1848 \
1849 product(bool, AlwaysActAsServerClassMachine, false, \
1850 "Always act like a server-class machine") \
1851 \
1852 product_pd(uint64_t, MaxRAM, \
1853 "Real memory size (in bytes) used to set maximum heap size") \
1854 \
1855 product(uintx, ErgoHeapSizeLimit, 0, \
1856 "Maximum ergonomically set heap size (in bytes); zero means use " \
1857 "MaxRAM / MaxRAMFraction") \
1858 \
1859 product(uintx, MaxRAMFraction, 4, \
1860 "Maximum fraction (1/n) of real memory used for maximum heap " \
1861 "size") \
1862 \
1863 product(uintx, DefaultMaxRAMFraction, 4, \
1864 "Maximum fraction (1/n) of real memory used for maximum heap " \
1865 "size; deprecated: to be renamed to MaxRAMFraction") \
1866 \
1867 product(uintx, MinRAMFraction, 2, \
1868 "Minimum fraction (1/n) of real memory used for maxmimum heap " \
1869 "size on systems with small physical memory size") \
1870 \
1871 product(uintx, InitialRAMFraction, 64, \
1872 "Fraction (1/n) of real memory used for initial heap size") \
1873 \
1874 product(bool, UseAutoGCSelectPolicy, false, \
1875 "Use automatic collection selection policy") \
1876 \
1877 product(uintx, AutoGCSelectPauseMillis, 5000, \
1878 "Automatic GC selection pause threshhold in ms") \
1879 \
1880 product(bool, UseAdaptiveSizePolicy, true, \
1881 "Use adaptive generation sizing policies") \
1882 \
1883 product(bool, UsePSAdaptiveSurvivorSizePolicy, true, \
1884 "Use adaptive survivor sizing policies") \
1885 \
1886 product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true, \
1887 "Use adaptive young-old sizing policies at minor collections") \
1888 \
1889 product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true, \
1890 "Use adaptive young-old sizing policies at major collections") \
1891 \
1892 product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
1893 "Use statistics from System.GC for adaptive size policy") \
1894 \
1895 product(bool, UseAdaptiveGCBoundary, false, \
1896 "Allow young-old boundary to move") \
1897 \
1898 develop(bool, TraceAdaptiveGCBoundary, false, \
1899 "Trace young-old boundary moves") \
1900 \
1901 develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
1902 "Resize the virtual spaces of the young or old generations") \
1903 \
1904 product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
1905 "Policy for changeing generation size for throughput goals") \
1906 \
1907 product(uintx, AdaptiveSizePausePolicy, 0, \
1908 "Policy for changing generation size for pause goals") \
1909 \
1910 develop(bool, PSAdjustTenuredGenForMinorPause, false, \
1911 "Adjust tenured generation to achive a minor pause goal") \
1912 \
1913 develop(bool, PSAdjustYoungGenForMajorPause, false, \
1914 "Adjust young generation to achive a major pause goal") \
1915 \
1916 product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
1917 "Number of steps where heuristics is used before data is used") \
1918 \
1919 develop(uintx, AdaptiveSizePolicyReadyThreshold, 5, \
1920 "Number of collections before the adaptive sizing is started") \
1921 \
1922 product(uintx, AdaptiveSizePolicyOutputInterval, 0, \
1923 "Collecton interval for printing information; zero => never") \
1924 \
1925 product(bool, UseAdaptiveSizePolicyFootprintGoal, true, \
1926 "Use adaptive minimum footprint as a goal") \
1927 \
1928 product(uintx, AdaptiveSizePolicyWeight, 10, \
1929 "Weight given to exponential resizing, between 0 and 100") \
1930 \
1931 product(uintx, AdaptiveTimeWeight, 25, \
1932 "Weight given to time in adaptive policy, between 0 and 100") \
1933 \
1934 product(uintx, PausePadding, 1, \
1935 "How much buffer to keep for pause time") \
1936 \
1937 product(uintx, PromotedPadding, 3, \
1938 "How much buffer to keep for promotion failure") \
1939 \
1940 product(uintx, SurvivorPadding, 3, \
1941 "How much buffer to keep for survivor overflow") \
1942 \
1943 product(uintx, AdaptivePermSizeWeight, 20, \
1944 "Weight for perm gen exponential resizing, between 0 and 100") \
1945 \
1946 product(uintx, PermGenPadding, 3, \
1947 "How much buffer to keep for perm gen sizing") \
1948 \
1949 product(uintx, ThresholdTolerance, 10, \
1950 "Allowed collection cost difference between generations") \
1951 \
1952 product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50, \
1953 "If collection costs are within margin, reduce both by full " \
1954 "delta") \
1955 \
1956 product(uintx, YoungGenerationSizeIncrement, 20, \
1957 "Adaptive size percentage change in young generation") \
1958 \
1959 product(uintx, YoungGenerationSizeSupplement, 80, \
1960 "Supplement to YoungedGenerationSizeIncrement used at startup") \
1961 \
1962 product(uintx, YoungGenerationSizeSupplementDecay, 8, \
1963 "Decay factor to YoungedGenerationSizeSupplement") \
1964 \
1965 product(uintx, TenuredGenerationSizeIncrement, 20, \
1966 "Adaptive size percentage change in tenured generation") \
1967 \
1968 product(uintx, TenuredGenerationSizeSupplement, 80, \
1969 "Supplement to TenuredGenerationSizeIncrement used at startup") \
1970 \
1971 product(uintx, TenuredGenerationSizeSupplementDecay, 2, \
1972 "Decay factor to TenuredGenerationSizeIncrement") \
1973 \
1974 product(uintx, MaxGCPauseMillis, max_uintx, \
1975 "Adaptive size policy maximum GC pause time goal in msec, " \
1976 "or (G1 Only) the max. GC time per MMU time slice") \
1977 \
1978 product(uintx, GCPauseIntervalMillis, 0, \
1979 "Time slice for MMU specification") \
1980 \
1981 product(uintx, MaxGCMinorPauseMillis, max_uintx, \
1982 "Adaptive size policy maximum GC minor pause time goal in msec") \
1983 \
1984 product(uintx, GCTimeRatio, 99, \
1985 "Adaptive size policy application time to GC time ratio") \
1986 \
1987 product(uintx, AdaptiveSizeDecrementScaleFactor, 4, \
1988 "Adaptive size scale down factor for shrinking") \
1989 \
1990 product(bool, UseAdaptiveSizeDecayMajorGCCost, true, \
1991 "Adaptive size decays the major cost for long major intervals") \
1992 \
1993 product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10, \
1994 "Time scale over which major costs decay") \
1995 \
1996 product(uintx, MinSurvivorRatio, 3, \
1997 "Minimum ratio of young generation/survivor space size") \
1998 \
1999 product(uintx, InitialSurvivorRatio, 8, \
2000 "Initial ratio of eden/survivor space size") \
2001 \
2002 product(uintx, BaseFootPrintEstimate, 256*M, \
2003 "Estimate of footprint other than Java Heap") \
2004 \
2005 product(bool, UseGCOverheadLimit, true, \
2006 "Use policy to limit of proportion of time spent in GC " \
2007 "before an OutOfMemory error is thrown") \
2008 \
2009 product(uintx, GCTimeLimit, 98, \
2010 "Limit of proportion of time spent in GC before an OutOfMemory" \
2011 "error is thrown (used with GCHeapFreeLimit)") \
2012 \
2013 product(uintx, GCHeapFreeLimit, 2, \
2014 "Minimum percentage of free space after a full GC before an " \
2015 "OutOfMemoryError is thrown (used with GCTimeLimit)") \
2016 \
2017 develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
2018 "Number of consecutive collections before gc time limit fires") \
2019 \
2020 product(bool, PrintAdaptiveSizePolicy, false, \
2021 "Print information about AdaptiveSizePolicy") \
2022 \
2023 product(intx, PrefetchCopyIntervalInBytes, -1, \
2024 "How far ahead to prefetch destination area (<= 0 means off)") \
2025 \
2026 product(intx, PrefetchScanIntervalInBytes, -1, \
2027 "How far ahead to prefetch scan area (<= 0 means off)") \
2028 \
2029 product(intx, PrefetchFieldsAhead, -1, \
2030 "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
2031 \
2032 develop(bool, UsePrefetchQueue, true, \
2033 "Use the prefetch queue during PS promotion") \
2034 \
2035 diagnostic(bool, VerifyBeforeExit, trueInDebug, \
2036 "Verify system before exiting") \
2037 \
2038 diagnostic(bool, VerifyBeforeGC, false, \
2039 "Verify memory system before GC") \
2040 \
2041 diagnostic(bool, VerifyAfterGC, false, \
2042 "Verify memory system after GC") \
2043 \
2044 diagnostic(bool, VerifyDuringGC, false, \
2045 "Verify memory system during GC (between phases)") \
2046 \
2047 diagnostic(bool, GCParallelVerificationEnabled, true, \
2048 "Enable parallel memory system verification") \
2049 \
2050 diagnostic(bool, DeferInitialCardMark, false, \
2051 "When +ReduceInitialCardMarks, explicitly defer any that " \
2052 "may arise from new_pre_store_barrier") \
2053 \
2054 diagnostic(bool, VerifyRememberedSets, false, \
2055 "Verify GC remembered sets") \
2056 \
2057 diagnostic(bool, VerifyObjectStartArray, true, \
2058 "Verify GC object start array if verify before/after") \
2059 \
2060 product(bool, DisableExplicitGC, false, \
2061 "Tells whether calling System.gc() does a full GC") \
2062 \
2063 notproduct(bool, CheckMemoryInitialization, false, \
2064 "Checks memory initialization") \
2065 \
2066 product(bool, CollectGen0First, false, \
2067 "Collect youngest generation before each full GC") \
2068 \
2069 diagnostic(bool, BindCMSThreadToCPU, false, \
2070 "Bind CMS Thread to CPU if possible") \
2071 \
2072 diagnostic(uintx, CPUForCMSThread, 0, \
2073 "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
2074 \
2075 product(bool, BindGCTaskThreadsToCPUs, false, \
2076 "Bind GCTaskThreads to CPUs if possible") \
2077 \
2078 product(bool, UseGCTaskAffinity, false, \
2079 "Use worker affinity when asking for GCTasks") \
2080 \
2081 product(uintx, ProcessDistributionStride, 4, \
2082 "Stride through processors when distributing processes") \
2083 \
2084 product(uintx, CMSCoordinatorYieldSleepCount, 10, \
2085 "number of times the coordinator GC thread will sleep while " \
2086 "yielding before giving up and resuming GC") \
2087 \
2088 product(uintx, CMSYieldSleepCount, 0, \
2089 "number of times a GC thread (minus the coordinator) " \
2090 "will sleep while yielding before giving up and resuming GC") \
2091 \
2092 /* gc tracing */ \
2093 manageable(bool, PrintGC, false, \
2094 "Print message at garbage collect") \
2095 \
2096 manageable(bool, PrintGCDetails, false, \
2097 "Print more details at garbage collect") \
2098 \
2099 manageable(bool, PrintGCDateStamps, false, \
2100 "Print date stamps at garbage collect") \
2101 \
2102 manageable(bool, PrintGCTimeStamps, false, \
2103 "Print timestamps at garbage collect") \
2104 \
2105 product(bool, PrintGCTaskTimeStamps, false, \
2106 "Print timestamps for individual gc worker thread tasks") \
2107 \
2108 develop(intx, ConcGCYieldTimeout, 0, \
2109 "If non-zero, assert that GC threads yield within this # of ms.") \
2110 \
2111 notproduct(bool, TraceMarkSweep, false, \
2112 "Trace mark sweep") \
2113 \
2114 product(bool, PrintReferenceGC, false, \
2115 "Print times spent handling reference objects during GC " \
2116 " (enabled only when PrintGCDetails)") \
2117 \
2118 develop(bool, TraceReferenceGC, false, \
2119 "Trace handling of soft/weak/final/phantom references") \
2120 \
2121 develop(bool, TraceFinalizerRegistration, false, \
2122 "Trace registration of final references") \
2123 \
2124 notproduct(bool, TraceScavenge, false, \
2125 "Trace scavenge") \
2126 \
2127 product_rw(bool, TraceClassLoading, false, \
2128 "Trace all classes loaded") \
2129 \
2130 product(bool, TraceClassLoadingPreorder, false, \
2131 "Trace all classes loaded in order referenced (not loaded)") \
2132 \
2133 product_rw(bool, TraceClassUnloading, false, \
2134 "Trace unloading of classes") \
2135 \
2136 product_rw(bool, TraceLoaderConstraints, false, \
2137 "Trace loader constraints") \
2138 \
2139 product(bool, TraceGen0Time, false, \
2140 "Trace accumulated time for Gen 0 collection") \
2141 \
2142 product(bool, TraceGen1Time, false, \
2143 "Trace accumulated time for Gen 1 collection") \
2144 \
2145 product(bool, PrintTenuringDistribution, false, \
2146 "Print tenuring age information") \
2147 \
2148 product_rw(bool, PrintHeapAtGC, false, \
2149 "Print heap layout before and after each GC") \
2150 \
2151 product_rw(bool, PrintHeapAtGCExtended, false, \
2152 "Prints extended information about the layout of the heap " \
2153 "when -XX:+PrintHeapAtGC is set") \
2154 \
2155 product(bool, PrintHeapAtSIGBREAK, true, \
2156 "Print heap layout in response to SIGBREAK") \
2157 \
2158 manageable(bool, PrintClassHistogramBeforeFullGC, false, \
2159 "Print a class histogram before any major stop-world GC") \
2160 \
2161 manageable(bool, PrintClassHistogramAfterFullGC, false, \
2162 "Print a class histogram after any major stop-world GC") \
2163 \
2164 manageable(bool, PrintClassHistogram, false, \
2165 "Print a histogram of class instances") \
2166 \
2167 develop(bool, TraceWorkGang, false, \
2168 "Trace activities of work gangs") \
2169 \
2170 product(bool, TraceParallelOldGCTasks, false, \
2171 "Trace multithreaded GC activity") \
2172 \
2173 develop(bool, TraceBlockOffsetTable, false, \
2174 "Print BlockOffsetTable maps") \
2175 \
2176 develop(bool, TraceCardTableModRefBS, false, \
2177 "Print CardTableModRefBS maps") \
2178 \
2179 develop(bool, TraceGCTaskManager, false, \
2180 "Trace actions of the GC task manager") \
2181 \
2182 develop(bool, TraceGCTaskQueue, false, \
2183 "Trace actions of the GC task queues") \
2184 \
2185 develop(bool, TraceGCTaskThread, false, \
2186 "Trace actions of the GC task threads") \
2187 \
2188 product(bool, PrintParallelOldGCPhaseTimes, false, \
2189 "Print the time taken by each parallel old gc phase." \
2190 "PrintGCDetails must also be enabled.") \
2191 \
2192 develop(bool, TraceParallelOldGCMarkingPhase, false, \
2193 "Trace parallel old gc marking phase") \
2194 \
2195 develop(bool, TraceParallelOldGCSummaryPhase, false, \
2196 "Trace parallel old gc summary phase") \
2197 \
2198 develop(bool, TraceParallelOldGCCompactionPhase, false, \
2199 "Trace parallel old gc compaction phase") \
2200 \
2201 develop(bool, TraceParallelOldGCDensePrefix, false, \
2202 "Trace parallel old gc dense prefix computation") \
2203 \
2204 develop(bool, IgnoreLibthreadGPFault, false, \
2205 "Suppress workaround for libthread GP fault") \
2206 \
2207 product(bool, PrintJNIGCStalls, false, \
2208 "Print diagnostic message when GC is stalled" \
2209 "by JNI critical section") \
2210 \
2211 /* JVMTI heap profiling */ \
2212 \
2213 diagnostic(bool, TraceJVMTIObjectTagging, false, \
2214 "Trace JVMTI object tagging calls") \
2215 \
2216 diagnostic(bool, VerifyBeforeIteration, false, \
2217 "Verify memory system before JVMTI iteration") \
2218 \
2219 /* compiler interface */ \
2220 \
2221 develop(bool, CIPrintCompilerName, false, \
2222 "when CIPrint is active, print the name of the active compiler") \
2223 \
2224 develop(bool, CIPrintCompileQueue, false, \
2225 "display the contents of the compile queue whenever a " \
2226 "compilation is enqueued") \
2227 \
2228 develop(bool, CIPrintRequests, false, \
2229 "display every request for compilation") \
2230 \
2231 product(bool, CITime, false, \
2232 "collect timing information for compilation") \
2233 \
2234 develop(bool, CITimeEach, false, \
2235 "display timing information after each successful compilation") \
2236 \
2237 develop(bool, CICountOSR, true, \
2238 "use a separate counter when assigning ids to osr compilations") \
2239 \
2240 develop(bool, CICompileNatives, true, \
2241 "compile native methods if supported by the compiler") \
2242 \
2243 develop_pd(bool, CICompileOSR, \
2244 "compile on stack replacement methods if supported by the " \
2245 "compiler") \
2246 \
2247 develop(bool, CIPrintMethodCodes, false, \
2248 "print method bytecodes of the compiled code") \
2249 \
2250 develop(bool, CIPrintTypeFlow, false, \
2251 "print the results of ciTypeFlow analysis") \
2252 \
2253 develop(bool, CITraceTypeFlow, false, \
2254 "detailed per-bytecode tracing of ciTypeFlow analysis") \
2255 \
2256 develop(intx, CICloneLoopTestLimit, 100, \
2257 "size limit for blocks heuristically cloned in ciTypeFlow") \
2258 \
2259 /* temp diagnostics */ \
2260 \
2261 diagnostic(bool, TraceRedundantCompiles, false, \
2262 "Have compile broker print when a request already in the queue is"\
2263 " requested again") \
2264 \
2265 diagnostic(bool, InitialCompileFast, false, \
2266 "Initial compile at CompLevel_fast_compile") \
2267 \
2268 diagnostic(bool, InitialCompileReallyFast, false, \
2269 "Initial compile at CompLevel_really_fast_compile (no profile)") \
2270 \
2271 diagnostic(bool, FullProfileOnReInterpret, true, \
2272 "On re-interpret unc-trap compile next at CompLevel_fast_compile")\
2273 \
2274 /* compiler */ \
2275 \
2276 product(intx, CICompilerCount, CI_COMPILER_COUNT, \
2277 "Number of compiler threads to run") \
2278 \
2279 product(intx, CompilationPolicyChoice, 0, \
2280 "which compilation policy (0/1)") \
2281 \
2282 develop(bool, UseStackBanging, true, \
2283 "use stack banging for stack overflow checks (required for " \
2284 "proper StackOverflow handling; disable only to measure cost " \
2285 "of stackbanging)") \
2286 \
2287 develop(bool, Use24BitFPMode, true, \
2288 "Set 24-bit FPU mode on a per-compile basis ") \
2289 \
2290 develop(bool, Use24BitFP, true, \
2291 "use FP instructions that produce 24-bit precise results") \
2292 \
2293 develop(bool, UseStrictFP, true, \
2294 "use strict fp if modifier strictfp is set") \
2295 \
2296 develop(bool, GenerateSynchronizationCode, true, \
2297 "generate locking/unlocking code for synchronized methods and " \
2298 "monitors") \
2299 \
2300 develop(bool, GenerateCompilerNullChecks, true, \
2301 "Generate explicit null checks for loads/stores/calls") \
2302 \
2303 develop(bool, GenerateRangeChecks, true, \
2304 "Generate range checks for array accesses") \
2305 \
2306 develop_pd(bool, ImplicitNullChecks, \
2307 "generate code for implicit null checks") \
2308 \
2309 product(bool, PrintSafepointStatistics, false, \
2310 "print statistics about safepoint synchronization") \
2311 \
2312 product(intx, PrintSafepointStatisticsCount, 300, \
2313 "total number of safepoint statistics collected " \
2314 "before printing them out") \
2315 \
2316 product(intx, PrintSafepointStatisticsTimeout, -1, \
2317 "print safepoint statistics only when safepoint takes" \
2318 " more than PrintSafepointSatisticsTimeout in millis") \
2319 \
2320 product(bool, TraceSafepointCleanupTime, false, \
2321 "print the break down of clean up tasks performed during" \
2322 " safepoint") \
2323 \
2324 develop(bool, InlineAccessors, true, \
2325 "inline accessor methods (get/set)") \
2326 \
2327 product(bool, Inline, true, \
2328 "enable inlining") \
2329 \
2330 product(bool, ClipInlining, true, \
2331 "clip inlining if aggregate method exceeds DesiredMethodLimit") \
2332 \
2333 develop(bool, UseCHA, true, \
2334 "enable CHA") \
2335 \
2336 product(bool, UseTypeProfile, true, \
2337 "Check interpreter profile for historically monomorphic calls") \
2338 \
2339 product(intx, TypeProfileMajorReceiverPercent, 90, \
2340 "% of major receiver type to all profiled receivers") \
2341 \
2342 notproduct(bool, TimeCompiler, false, \
2343 "time the compiler") \
2344 \
2345 notproduct(bool, TimeCompiler2, false, \
2346 "detailed time the compiler (requires +TimeCompiler)") \
2347 \
2348 diagnostic(bool, PrintInlining, false, \
2349 "prints inlining optimizations") \
2350 \
2351 diagnostic(bool, PrintIntrinsics, false, \
2352 "prints attempted and successful inlining of intrinsics") \
2353 \
2354 product(bool, UseCountLeadingZerosInstruction, false, \
2355 "Use count leading zeros instruction") \
2356 \
2357 product(bool, UsePopCountInstruction, false, \
2358 "Use population count instruction") \
2359 \
2360 diagnostic(ccstrlist, DisableIntrinsic, "", \
2361 "do not expand intrinsics whose (internal) names appear here") \
2362 \
2363 develop(bool, StressReflectiveCode, false, \
2364 "Use inexact types at allocations, etc., to test reflection") \
2365 \
2366 develop(bool, EagerInitialization, false, \
2367 "Eagerly initialize classes if possible") \
2368 \
2369 product(bool, Tier1UpdateMethodData, trueInTiered, \
2370 "Update methodDataOops in Tier1-generated code") \
2371 \
2372 develop(bool, TraceMethodReplacement, false, \
2373 "Print when methods are replaced do to recompilation") \
2374 \
2375 develop(bool, PrintMethodFlushing, false, \
2376 "print the nmethods being flushed") \
2377 \
2378 notproduct(bool, LogMultipleMutexLocking, false, \
2379 "log locking and unlocking of mutexes (only if multiple locks " \
2380 "are held)") \
2381 \
2382 develop(bool, UseRelocIndex, false, \
2383 "use an index to speed random access to relocations") \
2384 \
2385 develop(bool, StressCodeBuffers, false, \
2386 "Exercise code buffer expansion and other rare state changes") \
2387 \
2388 diagnostic(bool, DebugNonSafepoints, trueInDebug, \
2389 "Generate extra debugging info for non-safepoints in nmethods") \
2390 \
2391 diagnostic(bool, DebugInlinedCalls, true, \
2392 "If false, restricts profiled locations to the root method only") \
2393 \
2394 product(bool, PrintVMOptions, trueInDebug, \
2395 "Print flags that appeared on the command line") \
2396 \
2397 product(bool, IgnoreUnrecognizedVMOptions, false, \
2398 "Ignore unrecognized VM options") \
2399 \
2400 product(bool, PrintCommandLineFlags, false, \
2401 "Print flags specified on command line or set by ergonomics") \
2402 \
2403 product(bool, PrintFlagsInitial, false, \
2404 "Print all VM flags before argument processing and exit VM") \
2405 \
2406 product(bool, PrintFlagsFinal, false, \
2407 "Print all VM flags after argument and ergonomic processing") \
2408 \
2409 diagnostic(bool, SerializeVMOutput, true, \
2410 "Use a mutex to serialize output to tty and hotspot.log") \
2411 \
2412 diagnostic(bool, DisplayVMOutput, true, \
2413 "Display all VM output on the tty, independently of LogVMOutput") \
2414 \
2415 diagnostic(bool, LogVMOutput, trueInDebug, \
2416 "Save VM output to hotspot.log, or to LogFile") \
2417 \
2418 diagnostic(ccstr, LogFile, NULL, \
2419 "If LogVMOutput is on, save VM output to this file [hotspot.log]") \
2420 \
2421 product(ccstr, ErrorFile, NULL, \
2422 "If an error occurs, save the error data to this file " \
2423 "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
2424 \
2425 product(bool, DisplayVMOutputToStderr, false, \
2426 "If DisplayVMOutput is true, display all VM output to stderr") \
2427 \
2428 product(bool, DisplayVMOutputToStdout, false, \
2429 "If DisplayVMOutput is true, display all VM output to stdout") \
2430 \
2431 product(bool, UseHeavyMonitors, false, \
2432 "use heavyweight instead of lightweight Java monitors") \
2433 \
2434 notproduct(bool, PrintSymbolTableSizeHistogram, false, \
2435 "print histogram of the symbol table") \
2436 \
2437 notproduct(bool, ExitVMOnVerifyError, false, \
2438 "standard exit from VM if bytecode verify error " \
2439 "(only in debug mode)") \
2440 \
2441 notproduct(ccstr, AbortVMOnException, NULL, \
2442 "Call fatal if this exception is thrown. Example: " \
2443 "java -XX:AbortVMOnException=java.lang.NullPointerException Foo") \
2444 \
2445 notproduct(ccstr, AbortVMOnExceptionMessage, NULL, \
2446 "Call fatal if the exception pointed by AbortVMOnException " \
2447 "has this message.") \
2448 \
2449 develop(bool, DebugVtables, false, \
2450 "add debugging code to vtable dispatch") \
2451 \
2452 develop(bool, PrintVtables, false, \
2453 "print vtables when printing klass") \
2454 \
2455 notproduct(bool, PrintVtableStats, false, \
2456 "print vtables stats at end of run") \
2457 \
2458 develop(bool, TraceCreateZombies, false, \
2459 "trace creation of zombie nmethods") \
2460 \
2461 notproduct(bool, IgnoreLockingAssertions, false, \
2462 "disable locking assertions (for speed)") \
2463 \
2464 notproduct(bool, VerifyLoopOptimizations, false, \
2465 "verify major loop optimizations") \
2466 \
2467 product(bool, RangeCheckElimination, true, \
2468 "Split loop iterations to eliminate range checks") \
2469 \
2470 develop_pd(bool, UncommonNullCast, \
2471 "track occurrences of null in casts; adjust compiler tactics") \
2472 \
2473 develop(bool, TypeProfileCasts, true, \
2474 "treat casts like calls for purposes of type profiling") \
2475 \
2476 develop(bool, MonomorphicArrayCheck, true, \
2477 "Uncommon-trap array store checks that require full type check") \
2478 \
2479 develop(bool, DelayCompilationDuringStartup, true, \
2480 "Delay invoking the compiler until main application class is " \
2481 "loaded") \
2482 \
2483 develop(bool, CompileTheWorld, false, \
2484 "Compile all methods in all classes in bootstrap class path " \
2485 "(stress test)") \
2486 \
2487 develop(bool, CompileTheWorldPreloadClasses, true, \
2488 "Preload all classes used by a class before start loading") \
2489 \
2490 notproduct(bool, CompileTheWorldIgnoreInitErrors, false, \
2491 "Compile all methods although class initializer failed") \
2492 \
2493 notproduct(intx, CompileTheWorldSafepointInterval, 100, \
2494 "Force a safepoint every n compiles so sweeper can keep up") \
2495 \
2496 develop(bool, TraceIterativeGVN, false, \
2497 "Print progress during Iterative Global Value Numbering") \
2498 \
2499 develop(bool, FillDelaySlots, true, \
2500 "Fill delay slots (on SPARC only)") \
2501 \
2502 develop(bool, VerifyIterativeGVN, false, \
2503 "Verify Def-Use modifications during sparse Iterative Global " \
2504 "Value Numbering") \
2505 \
2506 notproduct(bool, TracePhaseCCP, false, \
2507 "Print progress during Conditional Constant Propagation") \
2508 \
2509 develop(bool, TimeLivenessAnalysis, false, \
2510 "Time computation of bytecode liveness analysis") \
2511 \
2512 develop(bool, TraceLivenessGen, false, \
2513 "Trace the generation of liveness analysis information") \
2514 \
2515 notproduct(bool, TraceLivenessQuery, false, \
2516 "Trace queries of liveness analysis information") \
2517 \
2518 notproduct(bool, CollectIndexSetStatistics, false, \
2519 "Collect information about IndexSets") \
2520 \
2521 develop(bool, PrintDominators, false, \
2522 "Print out dominator trees for GVN") \
2523 \
2524 develop(bool, UseLoopSafepoints, true, \
2525 "Generate Safepoint nodes in every loop") \
2526 \
2527 notproduct(bool, TraceCISCSpill, false, \
2528 "Trace allocators use of cisc spillable instructions") \
2529 \
2530 notproduct(bool, TraceSpilling, false, \
2531 "Trace spilling") \
2532 \
2533 product(bool, SplitIfBlocks, true, \
2534 "Clone compares and control flow through merge points to fold " \
2535 "some branches") \
2536 \
2537 develop(intx, FastAllocateSizeLimit, 128*K, \
2538 /* Note: This value is zero mod 1<<13 for a cheap sparc set. */ \
2539 "Inline allocations larger than this in doublewords must go slow")\
2540 \
2541 product(bool, AggressiveOpts, false, \
2542 "Enable aggressive optimizations - see arguments.cpp") \
2543 \
2544 product(bool, UseStringCache, false, \
2545 "Enable String cache capabilities on String.java") \
2546 \
2547 /* statistics */ \
2548 develop(bool, CountCompiledCalls, false, \
2549 "counts method invocations") \
2550 \
2551 notproduct(bool, CountRuntimeCalls, false, \
2552 "counts VM runtime calls") \
2553 \
2554 develop(bool, CountJNICalls, false, \
2555 "counts jni method invocations") \
2556 \
2557 notproduct(bool, CountJVMCalls, false, \
2558 "counts jvm method invocations") \
2559 \
2560 notproduct(bool, CountRemovableExceptions, false, \
2561 "count exceptions that could be replaced by branches due to " \
2562 "inlining") \
2563 \
2564 notproduct(bool, ICMissHistogram, false, \
2565 "produce histogram of IC misses") \
2566 \
2567 notproduct(bool, PrintClassStatistics, false, \
2568 "prints class statistics at end of run") \
2569 \
2570 notproduct(bool, PrintMethodStatistics, false, \
2571 "prints method statistics at end of run") \
2572 \
2573 /* interpreter */ \
2574 develop(bool, ClearInterpreterLocals, false, \
2575 "Always clear local variables of interpreter activations upon " \
2576 "entry") \
2577 \
2578 product_pd(bool, RewriteBytecodes, \
2579 "Allow rewriting of bytecodes (bytecodes are not immutable)") \
2580 \
2581 product_pd(bool, RewriteFrequentPairs, \
2582 "Rewrite frequently used bytecode pairs into a single bytecode") \
2583 \
2584 diagnostic(bool, PrintInterpreter, false, \
2585 "Prints the generated interpreter code") \
2586 \
2587 product(bool, UseInterpreter, true, \
2588 "Use interpreter for non-compiled methods") \
2589 \
2590 develop(bool, UseFastSignatureHandlers, true, \
2591 "Use fast signature handlers for native calls") \
2592 \
2593 develop(bool, UseV8InstrsOnly, false, \
2594 "Use SPARC-V8 Compliant instruction subset") \
2595 \
2596 product(bool, UseNiagaraInstrs, false, \
2597 "Use Niagara-efficient instruction subset") \
2598 \
2599 develop(bool, UseCASForSwap, false, \
2600 "Do not use swap instructions, but only CAS (in a loop) on SPARC")\
2601 \
2602 product(bool, UseLoopCounter, true, \
2603 "Increment invocation counter on backward branch") \
2604 \
2605 product(bool, UseFastEmptyMethods, true, \
2606 "Use fast method entry code for empty methods") \
2607 \
2608 product(bool, UseFastAccessorMethods, true, \
2609 "Use fast method entry code for accessor methods") \
2610 \
2611 product_pd(bool, UseOnStackReplacement, \
2612 "Use on stack replacement, calls runtime if invoc. counter " \
2613 "overflows in loop") \
2614 \
2615 notproduct(bool, TraceOnStackReplacement, false, \
2616 "Trace on stack replacement") \
2617 \
2618 develop(bool, PoisonOSREntry, true, \
2619 "Detect abnormal calls to OSR code") \
2620 \
2621 product_pd(bool, PreferInterpreterNativeStubs, \
2622 "Use always interpreter stubs for native methods invoked via " \
2623 "interpreter") \
2624 \
2625 develop(bool, CountBytecodes, false, \
2626 "Count number of bytecodes executed") \
2627 \
2628 develop(bool, PrintBytecodeHistogram, false, \
2629 "Print histogram of the executed bytecodes") \
2630 \
2631 develop(bool, PrintBytecodePairHistogram, false, \
2632 "Print histogram of the executed bytecode pairs") \
2633 \
2634 diagnostic(bool, PrintSignatureHandlers, false, \
2635 "Print code generated for native method signature handlers") \
2636 \
2637 develop(bool, VerifyOops, false, \
2638 "Do plausibility checks for oops") \
2639 \
2640 develop(bool, CheckUnhandledOops, false, \
2641 "Check for unhandled oops in VM code") \
2642 \
2643 develop(bool, VerifyJNIFields, trueInDebug, \
2644 "Verify jfieldIDs for instance fields") \
2645 \
2646 notproduct(bool, VerifyJNIEnvThread, false, \
2647 "Verify JNIEnv.thread == Thread::current() when entering VM " \
2648 "from JNI") \
2649 \
2650 develop(bool, VerifyFPU, false, \
2651 "Verify FPU state (check for NaN's, etc.)") \
2652 \
2653 develop(bool, VerifyThread, false, \
2654 "Watch the thread register for corruption (SPARC only)") \
2655 \
2656 develop(bool, VerifyActivationFrameSize, false, \
2657 "Verify that activation frame didn't become smaller than its " \
2658 "minimal size") \
2659 \
2660 develop(bool, TraceFrequencyInlining, false, \
2661 "Trace frequency based inlining") \
2662 \
2663 notproduct(bool, TraceTypeProfile, false, \
2664 "Trace type profile") \
2665 \
2666 develop_pd(bool, InlineIntrinsics, \
2667 "Inline intrinsics that can be statically resolved") \
2668 \
2669 product_pd(bool, ProfileInterpreter, \
2670 "Profile at the bytecode level during interpretation") \
2671 \
2672 develop_pd(bool, ProfileTraps, \
2673 "Profile deoptimization traps at the bytecode level") \
2674 \
2675 product(intx, ProfileMaturityPercentage, 20, \
2676 "number of method invocations/branches (expressed as % of " \
2677 "CompileThreshold) before using the method's profile") \
2678 \
2679 develop(bool, PrintMethodData, false, \
2680 "Print the results of +ProfileInterpreter at end of run") \
2681 \
2682 develop(bool, VerifyDataPointer, trueInDebug, \
2683 "Verify the method data pointer during interpreter profiling") \
2684 \
2685 develop(bool, VerifyCompiledCode, false, \
2686 "Include miscellaneous runtime verifications in nmethod code; " \
2687 "default off because it disturbs nmethod size heuristics") \
2688 \
2689 notproduct(bool, CrashGCForDumpingJavaThread, false, \
2690 "Manually make GC thread crash then dump java stack trace; " \
2691 "Test only") \
2692 \
2693 /* compilation */ \
2694 product(bool, UseCompiler, true, \
2695 "use compilation") \
2696 \
2697 develop(bool, TraceCompilationPolicy, false, \
2698 "Trace compilation policy") \
2699 \
2700 develop(bool, TimeCompilationPolicy, false, \
2701 "Time the compilation policy") \
2702 \
2703 product(bool, UseCounterDecay, true, \
2704 "adjust recompilation counters") \
2705 \
2706 develop(intx, CounterHalfLifeTime, 30, \
2707 "half-life time of invocation counters (in secs)") \
2708 \
2709 develop(intx, CounterDecayMinIntervalLength, 500, \
2710 "Min. ms. between invocation of CounterDecay") \
2711 \
2712 product(bool, AlwaysCompileLoopMethods, false, \
2713 "when using recompilation, never interpret methods " \
2714 "containing loops") \
2715 \
2716 product(bool, DontCompileHugeMethods, true, \
2717 "don't compile methods > HugeMethodLimit") \
2718 \
2719 /* Bytecode escape analysis estimation. */ \
2720 product(bool, EstimateArgEscape, true, \
2721 "Analyze bytecodes to estimate escape state of arguments") \
2722 \
2723 product(intx, BCEATraceLevel, 0, \
2724 "How much tracing to do of bytecode escape analysis estimates") \
2725 \
2726 product(intx, MaxBCEAEstimateLevel, 5, \
2727 "Maximum number of nested calls that are analyzed by BC EA.") \
2728 \
2729 product(intx, MaxBCEAEstimateSize, 150, \
2730 "Maximum bytecode size of a method to be analyzed by BC EA.") \
2731 \
2732 product(intx, AllocatePrefetchStyle, 1, \
2733 "0 = no prefetch, " \
2734 "1 = prefetch instructions for each allocation, " \
2735 "2 = use TLAB watermark to gate allocation prefetch, " \
2736 "3 = use BIS instruction on Sparc for allocation prefetch") \
2737 \
2738 product(intx, AllocatePrefetchDistance, -1, \
2739 "Distance to prefetch ahead of allocation pointer") \
2740 \
2741 product(intx, AllocatePrefetchLines, 1, \
2742 "Number of lines to prefetch ahead of allocation pointer") \
2743 \
2744 product(intx, AllocatePrefetchStepSize, 16, \
2745 "Step size in bytes of sequential prefetch instructions") \
2746 \
2747 product(intx, AllocatePrefetchInstr, 0, \
2748 "Prefetch instruction to prefetch ahead of allocation pointer") \
2749 \
2750 product(intx, ReadPrefetchInstr, 0, \
2751 "Prefetch instruction to prefetch ahead") \
2752 \
2753 /* deoptimization */ \
2754 develop(bool, TraceDeoptimization, false, \
2755 "Trace deoptimization") \
2756 \
2757 develop(bool, DebugDeoptimization, false, \
2758 "Tracing various information while debugging deoptimization") \
2759 \
2760 product(intx, SelfDestructTimer, 0, \
2761 "Will cause VM to terminate after a given time (in minutes) " \
2762 "(0 means off)") \
2763 \
2764 product(intx, MaxJavaStackTraceDepth, 1024, \
2765 "Max. no. of lines in the stack trace for Java exceptions " \
2766 "(0 means all)") \
2767 \
2768 develop(intx, GuaranteedSafepointInterval, 1000, \
2769 "Guarantee a safepoint (at least) every so many milliseconds " \
2770 "(0 means none)") \
2771 \
2772 product(intx, SafepointTimeoutDelay, 10000, \
2773 "Delay in milliseconds for option SafepointTimeout") \
2774 \
2775 product(intx, NmethodSweepFraction, 4, \
2776 "Number of invocations of sweeper to cover all nmethods") \
2777 \
2778 product(intx, NmethodSweepCheckInterval, 5, \
2779 "Compilers wake up every n seconds to possibly sweep nmethods") \
2780 \
2781 notproduct(intx, MemProfilingInterval, 500, \
2782 "Time between each invocation of the MemProfiler") \
2783 \
2784 develop(intx, MallocCatchPtr, -1, \
2785 "Hit breakpoint when mallocing/freeing this pointer") \
2786 \
2787 notproduct(intx, AssertRepeat, 1, \
2788 "number of times to evaluate expression in assert " \
2789 "(to estimate overhead); only works with -DUSE_REPEATED_ASSERTS") \
2790 \
2791 notproduct(ccstrlist, SuppressErrorAt, "", \
2792 "List of assertions (file:line) to muzzle") \
2793 \
2794 notproduct(uintx, HandleAllocationLimit, 1024, \
2795 "Threshold for HandleMark allocation when +TraceHandleAllocation "\
2796 "is used") \
2797 \
2798 develop(uintx, TotalHandleAllocationLimit, 1024, \
2799 "Threshold for total handle allocation when " \
2800 "+TraceHandleAllocation is used") \
2801 \
2802 develop(intx, StackPrintLimit, 100, \
2803 "number of stack frames to print in VM-level stack dump") \
2804 \
2805 notproduct(intx, MaxElementPrintSize, 256, \
2806 "maximum number of elements to print") \
2807 \
2808 notproduct(intx, MaxSubklassPrintSize, 4, \
2809 "maximum number of subklasses to print when printing klass") \
2810 \
2811 product(intx, MaxInlineLevel, 9, \
2812 "maximum number of nested calls that are inlined") \
2813 \
2814 product(intx, MaxRecursiveInlineLevel, 1, \
2815 "maximum number of nested recursive calls that are inlined") \
2816 \
2817 product_pd(intx, InlineSmallCode, \
2818 "Only inline already compiled methods if their code size is " \
2819 "less than this") \
2820 \
2821 product(intx, MaxInlineSize, 35, \
2822 "maximum bytecode size of a method to be inlined") \
2823 \
2824 product_pd(intx, FreqInlineSize, \
2825 "maximum bytecode size of a frequent method to be inlined") \
2826 \
2827 product(intx, MaxTrivialSize, 6, \
2828 "maximum bytecode size of a trivial method to be inlined") \
2829 \
2830 product(intx, MinInliningThreshold, 250, \
2831 "min. invocation count a method needs to have to be inlined") \
2832 \
2833 develop(intx, AlignEntryCode, 4, \
2834 "aligns entry code to specified value (in bytes)") \
2835 \
2836 develop(intx, MethodHistogramCutoff, 100, \
2837 "cutoff value for method invoc. histogram (+CountCalls)") \
2838 \
2839 develop(intx, ProfilerNumberOfInterpretedMethods, 25, \
2840 "# of interpreted methods to show in profile") \
2841 \
2842 develop(intx, ProfilerNumberOfCompiledMethods, 25, \
2843 "# of compiled methods to show in profile") \
2844 \
2845 develop(intx, ProfilerNumberOfStubMethods, 25, \
2846 "# of stub methods to show in profile") \
2847 \
2848 develop(intx, ProfilerNumberOfRuntimeStubNodes, 25, \
2849 "# of runtime stub nodes to show in profile") \
2850 \
2851 product(intx, ProfileIntervalsTicks, 100, \
2852 "# of ticks between printing of interval profile " \
2853 "(+ProfileIntervals)") \
2854 \
2855 notproduct(intx, ScavengeALotInterval, 1, \
2856 "Interval between which scavenge will occur with +ScavengeALot") \
2857 \
2858 notproduct(intx, FullGCALotInterval, 1, \
2859 "Interval between which full gc will occur with +FullGCALot") \
2860 \
2861 notproduct(intx, FullGCALotStart, 0, \
2862 "For which invocation to start FullGCAlot") \
2863 \
2864 notproduct(intx, FullGCALotDummies, 32*K, \
2865 "Dummy object allocated with +FullGCALot, forcing all objects " \
2866 "to move") \
2867 \
2868 develop(intx, DontYieldALotInterval, 10, \
2869 "Interval between which yields will be dropped (milliseconds)") \
2870 \
2871 develop(intx, MinSleepInterval, 1, \
2872 "Minimum sleep() interval (milliseconds) when " \
2873 "ConvertSleepToYield is off (used for SOLARIS)") \
2874 \
2875 product(intx, EventLogLength, 2000, \
2876 "maximum nof events in event log") \
2877 \
2878 develop(intx, ProfilerPCTickThreshold, 15, \
2879 "Number of ticks in a PC buckets to be a hotspot") \
2880 \
2881 notproduct(intx, DeoptimizeALotInterval, 5, \
2882 "Number of exits until DeoptimizeALot kicks in") \
2883 \
2884 notproduct(intx, ZombieALotInterval, 5, \
2885 "Number of exits until ZombieALot kicks in") \
2886 \
2887 develop(bool, StressNonEntrant, false, \
2888 "Mark nmethods non-entrant at registration") \
2889 \
2890 diagnostic(intx, MallocVerifyInterval, 0, \
2891 "if non-zero, verify C heap after every N calls to " \
2892 "malloc/realloc/free") \
2893 \
2894 diagnostic(intx, MallocVerifyStart, 0, \
2895 "if non-zero, start verifying C heap after Nth call to " \
2896 "malloc/realloc/free") \
2897 \
2898 product(intx, TypeProfileWidth, 2, \
2899 "number of receiver types to record in call/cast profile") \
2900 \
2901 develop(intx, BciProfileWidth, 2, \
2902 "number of return bci's to record in ret profile") \
2903 \
2904 product(intx, PerMethodRecompilationCutoff, 400, \
2905 "After recompiling N times, stay in the interpreter (-1=>'Inf')") \
2906 \
2907 product(intx, PerBytecodeRecompilationCutoff, 200, \
2908 "Per-BCI limit on repeated recompilation (-1=>'Inf')") \
2909 \
2910 product(intx, PerMethodTrapLimit, 100, \
2911 "Limit on traps (of one kind) in a method (includes inlines)") \
2912 \
2913 product(intx, PerBytecodeTrapLimit, 4, \
2914 "Limit on traps (of one kind) at a particular BCI") \
2915 \
2916 develop(intx, FreqCountInvocations, 1, \
2917 "Scaling factor for branch frequencies (deprecated)") \
2918 \
2919 develop(intx, InlineFrequencyRatio, 20, \
2920 "Ratio of call site execution to caller method invocation") \
2921 \
2922 develop_pd(intx, InlineFrequencyCount, \
2923 "Count of call site execution necessary to trigger frequent " \
2924 "inlining") \
2925 \
2926 develop(intx, InlineThrowCount, 50, \
2927 "Force inlining of interpreted methods that throw this often") \
2928 \
2929 develop(intx, InlineThrowMaxSize, 200, \
2930 "Force inlining of throwing methods smaller than this") \
2931 \
2932 product(intx, AliasLevel, 3, \
2933 "0 for no aliasing, 1 for oop/field/static/array split, " \
2934 "2 for class split, 3 for unique instances") \
2935 \
2936 develop(bool, VerifyAliases, false, \
2937 "perform extra checks on the results of alias analysis") \
2938 \
2939 develop(intx, ProfilerNodeSize, 1024, \
2940 "Size in K to allocate for the Profile Nodes of each thread") \
2941 \
2942 develop(intx, V8AtomicOperationUnderLockSpinCount, 50, \
2943 "Number of times to spin wait on a v8 atomic operation lock") \
2944 \
2945 product(intx, ReadSpinIterations, 100, \
2946 "Number of read attempts before a yield (spin inner loop)") \
2947 \
2948 product_pd(intx, PreInflateSpin, \
2949 "Number of times to spin wait before inflation") \
2950 \
2951 product(intx, PreBlockSpin, 10, \
2952 "Number of times to spin in an inflated lock before going to " \
2953 "an OS lock") \
2954 \
2955 /* gc parameters */ \
2956 product(uintx, InitialHeapSize, 0, \
2957 "Initial heap size (in bytes); zero means OldSize + NewSize") \
2958 \
2959 product(uintx, MaxHeapSize, ScaleForWordSize(96*M), \
2960 "Maximum heap size (in bytes)") \
2961 \
2962 product(uintx, OldSize, ScaleForWordSize(4*M), \
2963 "Initial tenured generation size (in bytes)") \
2964 \
2965 product(uintx, NewSize, ScaleForWordSize(1*M), \
2966 "Initial new generation size (in bytes)") \
2967 \
2968 product(uintx, MaxNewSize, max_uintx, \
2969 "Maximum new generation size (in bytes), max_uintx means set " \
2970 "ergonomically") \
2971 \
2972 product(uintx, PretenureSizeThreshold, 0, \
2973 "Maximum size in bytes of objects allocated in DefNew " \
2974 "generation; zero means no maximum") \
2975 \
2976 product(uintx, TLABSize, 0, \
2977 "Starting TLAB size (in bytes); zero means set ergonomically") \
2978 \
2979 product(uintx, MinTLABSize, 2*K, \
2980 "Minimum allowed TLAB size (in bytes)") \
2981 \
2982 product(uintx, TLABAllocationWeight, 35, \
2983 "Allocation averaging weight") \
2984 \
2985 product(uintx, TLABWasteTargetPercent, 1, \
2986 "Percentage of Eden that can be wasted") \
2987 \
2988 product(uintx, TLABRefillWasteFraction, 64, \
2989 "Max TLAB waste at a refill (internal fragmentation)") \
2990 \
2991 product(uintx, TLABWasteIncrement, 4, \
2992 "Increment allowed waste at slow allocation") \
2993 \
2994 product(intx, SurvivorRatio, 8, \
2995 "Ratio of eden/survivor space size") \
2996 \
2997 product(intx, NewRatio, 2, \
2998 "Ratio of new/old generation sizes") \
2999 \
3000 product(uintx, MaxLiveObjectEvacuationRatio, 100, \
3001 "Max percent of eden objects that will be live at scavenge") \
3002 \
3003 product_pd(uintx, NewSizeThreadIncrease, \
3004 "Additional size added to desired new generation size per " \
3005 "non-daemon thread (in bytes)") \
3006 \
3007 product_pd(uintx, PermSize, \
3008 "Initial size of permanent generation (in bytes)") \
3009 \
3010 product_pd(uintx, MaxPermSize, \
3011 "Maximum size of permanent generation (in bytes)") \
3012 \
3013 product(uintx, MinHeapFreeRatio, 40, \
3014 "Min percentage of heap free after GC to avoid expansion") \
3015 \
3016 product(uintx, MaxHeapFreeRatio, 70, \
3017 "Max percentage of heap free after GC to avoid shrinking") \
3018 \
3019 product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
3020 "Number of milliseconds per MB of free space in the heap") \
3021 \
3022 product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
3023 "Min change in heap space due to GC (in bytes)") \
3024 \
3025 product(uintx, MinPermHeapExpansion, ScaleForWordSize(256*K), \
3026 "Min expansion of permanent heap (in bytes)") \
3027 \
3028 product(uintx, MaxPermHeapExpansion, ScaleForWordSize(4*M), \
3029 "Max expansion of permanent heap without full GC (in bytes)") \
3030 \
3031 product(intx, QueuedAllocationWarningCount, 0, \
3032 "Number of times an allocation that queues behind a GC " \
3033 "will retry before printing a warning") \
3034 \
3035 diagnostic(uintx, VerifyGCStartAt, 0, \
3036 "GC invoke count where +VerifyBefore/AfterGC kicks in") \
3037 \
3038 diagnostic(intx, VerifyGCLevel, 0, \
3039 "Generation level at which to start +VerifyBefore/AfterGC") \
3040 \
3041 develop(uintx, ExitAfterGCNum, 0, \
3042 "If non-zero, exit after this GC.") \
3043 \
3044 product(intx, MaxTenuringThreshold, 15, \
3045 "Maximum value for tenuring threshold") \
3046 \
3047 product(intx, InitialTenuringThreshold, 7, \
3048 "Initial value for tenuring threshold") \
3049 \
3050 product(intx, TargetSurvivorRatio, 50, \
3051 "Desired percentage of survivor space used after scavenge") \
3052 \
3053 product(uintx, MarkSweepDeadRatio, 5, \
3054 "Percentage (0-100) of the old gen allowed as dead wood." \
3055 "Serial mark sweep treats this as both the min and max value." \
3056 "CMS uses this value only if it falls back to mark sweep." \
3057 "Par compact uses a variable scale based on the density of the" \
3058 "generation and treats this as the max value when the heap is" \
3059 "either completely full or completely empty. Par compact also" \
3060 "has a smaller default value; see arguments.cpp.") \
3061 \
3062 product(uintx, PermMarkSweepDeadRatio, 20, \
3063 "Percentage (0-100) of the perm gen allowed as dead wood." \
3064 "See MarkSweepDeadRatio for collector-specific comments.") \
3065 \
3066 product(intx, MarkSweepAlwaysCompactCount, 4, \
3067 "How often should we fully compact the heap (ignoring the dead " \
3068 "space parameters)") \
3069 \
3070 product(intx, PrintCMSStatistics, 0, \
3071 "Statistics for CMS") \
3072 \
3073 product(bool, PrintCMSInitiationStatistics, false, \
3074 "Statistics for initiating a CMS collection") \
3075 \
3076 product(intx, PrintFLSStatistics, 0, \
3077 "Statistics for CMS' FreeListSpace") \
3078 \
3079 product(intx, PrintFLSCensus, 0, \
3080 "Census for CMS' FreeListSpace") \
3081 \
3082 develop(uintx, GCExpandToAllocateDelayMillis, 0, \
3083 "Delay in ms between expansion and allocation") \
3084 \
3085 product(intx, DeferThrSuspendLoopCount, 4000, \
3086 "(Unstable) Number of times to iterate in safepoint loop " \
3087 " before blocking VM threads ") \
3088 \
3089 product(intx, DeferPollingPageLoopCount, -1, \
3090 "(Unsafe,Unstable) Number of iterations in safepoint loop " \
3091 "before changing safepoint polling page to RO ") \
3092 \
3093 product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
3094 \
3095 product(bool, PSChunkLargeArrays, true, \
3096 "true: process large arrays in chunks") \
3097 \
3098 product(uintx, GCDrainStackTargetSize, 64, \
3099 "how many entries we'll try to leave on the stack during " \
3100 "parallel GC") \
3101 \
3102 /* stack parameters */ \
3103 product_pd(intx, StackYellowPages, \
3104 "Number of yellow zone (recoverable overflows) pages") \
3105 \
3106 product_pd(intx, StackRedPages, \
3107 "Number of red zone (unrecoverable overflows) pages") \
3108 \
3109 product_pd(intx, StackShadowPages, \
3110 "Number of shadow zone (for overflow checking) pages" \
3111 " this should exceed the depth of the VM and native call stack") \
3112 \
3113 product_pd(intx, ThreadStackSize, \
3114 "Thread Stack Size (in Kbytes)") \
3115 \
3116 product_pd(intx, VMThreadStackSize, \
3117 "Non-Java Thread Stack Size (in Kbytes)") \
3118 \
3119 product_pd(intx, CompilerThreadStackSize, \
3120 "Compiler Thread Stack Size (in Kbytes)") \
3121 \
3122 develop_pd(uintx, JVMInvokeMethodSlack, \
3123 "Stack space (bytes) required for JVM_InvokeMethod to complete") \
3124 \
3125 product(uintx, ThreadSafetyMargin, 50*M, \
3126 "Thread safety margin is used on fixed-stack LinuxThreads (on " \
3127 "Linux/x86 only) to prevent heap-stack collision. Set to 0 to " \
3128 "disable this feature") \
3129 \
3130 /* code cache parameters */ \
3131 develop(uintx, CodeCacheSegmentSize, 64, \
3132 "Code cache segment size (in bytes) - smallest unit of " \
3133 "allocation") \
3134 \
3135 develop_pd(intx, CodeEntryAlignment, \
3136 "Code entry alignment for generated code (in bytes)") \
3137 \
3138 product_pd(intx, OptoLoopAlignment, \
3139 "Align inner loops to zero relative to this modulus") \
3140 \
3141 product_pd(uintx, InitialCodeCacheSize, \
3142 "Initial code cache size (in bytes)") \
3143 \
3144 product_pd(uintx, ReservedCodeCacheSize, \
3145 "Reserved code cache size (in bytes) - maximum code cache size") \
3146 \
3147 product(uintx, CodeCacheMinimumFreeSpace, 500*K, \
3148 "When less than X space left, we stop compiling.") \
3149 \
3150 product_pd(uintx, CodeCacheExpansionSize, \
3151 "Code cache expansion size (in bytes)") \
3152 \
3153 develop_pd(uintx, CodeCacheMinBlockLength, \
3154 "Minimum number of segments in a code cache block.") \
3155 \
3156 notproduct(bool, ExitOnFullCodeCache, false, \
3157 "Exit the VM if we fill the code cache.") \
3158 \
3159 product(bool, UseCodeCacheFlushing, false, \
3160 "Attempt to clean the code cache before shutting off compiler") \
3161 \
3162 product(intx, MinCodeCacheFlushingInterval, 30, \
3163 "Min number of seconds between code cache cleaning sessions") \
3164 \
3165 product(uintx, CodeCacheFlushingMinimumFreeSpace, 1500*K, \
3166 "When less than X space left, start code cache cleaning") \
3167 \
3168 /* interpreter debugging */ \
3169 develop(intx, BinarySwitchThreshold, 5, \
3170 "Minimal number of lookupswitch entries for rewriting to binary " \
3171 "switch") \
3172 \
3173 develop(intx, StopInterpreterAt, 0, \
3174 "Stops interpreter execution at specified bytecode number") \
3175 \
3176 develop(intx, TraceBytecodesAt, 0, \
3177 "Traces bytecodes starting with specified bytecode number") \
3178 \
3179 /* compiler interface */ \
3180 develop(intx, CIStart, 0, \
3181 "the id of the first compilation to permit") \
3182 \
3183 develop(intx, CIStop, -1, \
3184 "the id of the last compilation to permit") \
3185 \
3186 develop(intx, CIStartOSR, 0, \
3187 "the id of the first osr compilation to permit " \
3188 "(CICountOSR must be on)") \
3189 \
3190 develop(intx, CIStopOSR, -1, \
3191 "the id of the last osr compilation to permit " \
3192 "(CICountOSR must be on)") \
3193 \
3194 develop(intx, CIBreakAtOSR, -1, \
3195 "id of osr compilation to break at") \
3196 \
3197 develop(intx, CIBreakAt, -1, \
3198 "id of compilation to break at") \
3199 \
3200 product(ccstrlist, CompileOnly, "", \
3201 "List of methods (pkg/class.name) to restrict compilation to") \
3202 \
3203 product(ccstr, CompileCommandFile, NULL, \
3204 "Read compiler commands from this file [.hotspot_compiler]") \
3205 \
3206 product(ccstrlist, CompileCommand, "", \
3207 "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>") \
3208 \
3209 product(bool, CICompilerCountPerCPU, false, \
3210 "1 compiler thread for log(N CPUs)") \
3211 \
3212 develop(intx, CIFireOOMAt, -1, \
3213 "Fire OutOfMemoryErrors throughout CI for testing the compiler " \
3214 "(non-negative value throws OOM after this many CI accesses " \
3215 "in each compile)") \
3216 \
3217 develop(intx, CIFireOOMAtDelay, -1, \
3218 "Wait for this many CI accesses to occur in all compiles before " \
3219 "beginning to throw OutOfMemoryErrors in each compile") \
3220 \
3221 notproduct(bool, CIObjectFactoryVerify, false, \
3222 "enable potentially expensive verification in ciObjectFactory") \
3223 \
3224 /* Priorities */ \
3225 product_pd(bool, UseThreadPriorities, "Use native thread priorities") \
3226 \
3227 product(intx, ThreadPriorityPolicy, 0, \
3228 "0 : Normal. "\
3229 " VM chooses priorities that are appropriate for normal "\
3230 " applications. On Solaris NORM_PRIORITY and above are mapped "\
3231 " to normal native priority. Java priorities below NORM_PRIORITY"\
3232 " map to lower native priority values. On Windows applications"\
3233 " are allowed to use higher native priorities. However, with "\
3234 " ThreadPriorityPolicy=0, VM will not use the highest possible"\
3235 " native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may "\
3236 " interfere with system threads. On Linux thread priorities "\
3237 " are ignored because the OS does not support static priority "\
3238 " in SCHED_OTHER scheduling class which is the only choice for"\
3239 " non-root, non-realtime applications. "\
3240 "1 : Aggressive. "\
3241 " Java thread priorities map over to the entire range of "\
3242 " native thread priorities. Higher Java thread priorities map "\
3243 " to higher native thread priorities. This policy should be "\
3244 " used with care, as sometimes it can cause performance "\
3245 " degradation in the application and/or the entire system. On "\
3246 " Linux this policy requires root privilege.") \
3247 \
3248 product(bool, ThreadPriorityVerbose, false, \
3249 "print priority changes") \
3250 \
3251 product(intx, DefaultThreadPriority, -1, \
3252 "what native priority threads run at if not specified elsewhere (-1 means no change)") \
3253 \
3254 product(intx, CompilerThreadPriority, -1, \
3255 "what priority should compiler threads run at (-1 means no change)") \
3256 \
3257 product(intx, VMThreadPriority, -1, \
3258 "what priority should VM threads run at (-1 means no change)") \
3259 \
3260 product(bool, CompilerThreadHintNoPreempt, true, \
3261 "(Solaris only) Give compiler threads an extra quanta") \
3262 \
3263 product(bool, VMThreadHintNoPreempt, false, \
3264 "(Solaris only) Give VM thread an extra quanta") \
3265 \
3266 product(intx, JavaPriority1_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3267 product(intx, JavaPriority2_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3268 product(intx, JavaPriority3_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3269 product(intx, JavaPriority4_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3270 product(intx, JavaPriority5_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3271 product(intx, JavaPriority6_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3272 product(intx, JavaPriority7_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3273 product(intx, JavaPriority8_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3274 product(intx, JavaPriority9_To_OSPriority, -1, "Map Java priorities to OS priorities") \
3275 product(intx, JavaPriority10_To_OSPriority,-1, "Map Java priorities to OS priorities") \
3276 \
3277 /* compiler debugging */ \
3278 notproduct(intx, CompileTheWorldStartAt, 1, \
3279 "First class to consider when using +CompileTheWorld") \
3280 \
3281 notproduct(intx, CompileTheWorldStopAt, max_jint, \
3282 "Last class to consider when using +CompileTheWorld") \
3283 \
3284 develop(intx, NewCodeParameter, 0, \
3285 "Testing Only: Create a dedicated integer parameter before " \
3286 "putback") \
3287 \
3288 /* new oopmap storage allocation */ \
3289 develop(intx, MinOopMapAllocation, 8, \
3290 "Minimum number of OopMap entries in an OopMapSet") \
3291 \
3292 /* Background Compilation */ \
3293 develop(intx, LongCompileThreshold, 50, \
3294 "Used with +TraceLongCompiles") \
3295 \
3296 product(intx, StarvationMonitorInterval, 200, \
3297 "Pause between each check in ms") \
3298 \
3299 /* recompilation */ \
3300 product_pd(intx, CompileThreshold, \
3301 "number of interpreted method invocations before (re-)compiling") \
3302 \
3303 product_pd(intx, BackEdgeThreshold, \
3304 "Interpreter Back edge threshold at which an OSR compilation is invoked")\
3305 \
3306 product(intx, Tier1BytecodeLimit, 10, \
3307 "Must have at least this many bytecodes before tier1" \
3308 "invocation counters are used") \
3309 \
3310 product_pd(intx, Tier2CompileThreshold, \
3311 "threshold at which a tier 2 compilation is invoked") \
3312 \
3313 product_pd(intx, Tier2BackEdgeThreshold, \
3314 "Back edge threshold at which a tier 2 compilation is invoked") \
3315 \
3316 product_pd(intx, Tier3CompileThreshold, \
3317 "threshold at which a tier 3 compilation is invoked") \
3318 \
3319 product_pd(intx, Tier3BackEdgeThreshold, \
3320 "Back edge threshold at which a tier 3 compilation is invoked") \
3321 \
3322 product_pd(intx, Tier4CompileThreshold, \
3323 "threshold at which a tier 4 compilation is invoked") \
3324 \
3325 product_pd(intx, Tier4BackEdgeThreshold, \
3326 "Back edge threshold at which a tier 4 compilation is invoked") \
3327 \
3328 product_pd(bool, TieredCompilation, \
3329 "Enable two-tier compilation") \
3330 \
3331 product(bool, StressTieredRuntime, false, \
3332 "Alternate client and server compiler on compile requests") \
3333 \
3334 product_pd(intx, OnStackReplacePercentage, \
3335 "NON_TIERED number of method invocations/branches (expressed as %"\
3336 "of CompileThreshold) before (re-)compiling OSR code") \
3337 \
3338 product(intx, InterpreterProfilePercentage, 33, \
3339 "NON_TIERED number of method invocations/branches (expressed as %"\
3340 "of CompileThreshold) before profiling in the interpreter") \
3341 \
3342 develop(intx, MaxRecompilationSearchLength, 10, \
3343 "max. # frames to inspect searching for recompilee") \
3344 \
3345 develop(intx, MaxInterpretedSearchLength, 3, \
3346 "max. # interp. frames to skip when searching for recompilee") \
3347 \
3348 develop(intx, DesiredMethodLimit, 8000, \
3349 "desired max. method size (in bytecodes) after inlining") \
3350 \
3351 develop(intx, HugeMethodLimit, 8000, \
3352 "don't compile methods larger than this if " \
3353 "+DontCompileHugeMethods") \
3354 \
3355 /* New JDK 1.4 reflection implementation */ \
3356 \
3357 develop(bool, UseNewReflection, true, \
3358 "Temporary flag for transition to reflection based on dynamic " \
3359 "bytecode generation in 1.4; can no longer be turned off in 1.4 " \
3360 "JDK, and is unneeded in 1.3 JDK, but marks most places VM " \
3361 "changes were needed") \
3362 \
3363 develop(bool, VerifyReflectionBytecodes, false, \
3364 "Force verification of 1.4 reflection bytecodes. Does not work " \
3365 "in situations like that described in 4486457 or for " \
3366 "constructors generated for serialization, so can not be enabled "\
3367 "in product.") \
3368 \
3369 product(bool, ReflectionWrapResolutionErrors, true, \
3370 "Temporary flag for transition to AbstractMethodError wrapped " \
3371 "in InvocationTargetException. See 6531596") \
3372 \
3373 \
3374 develop(intx, FastSuperclassLimit, 8, \
3375 "Depth of hardwired instanceof accelerator array") \
3376 \
3377 /* Properties for Java libraries */ \
3378 \
3379 product(intx, MaxDirectMemorySize, -1, \
3380 "Maximum total size of NIO direct-buffer allocations") \
3381 \
3382 /* temporary developer defined flags */ \
3383 \
3384 diagnostic(bool, UseNewCode, false, \
3385 "Testing Only: Use the new version while testing") \
3386 \
3387 diagnostic(bool, UseNewCode2, false, \
3388 "Testing Only: Use the new version while testing") \
3389 \
3390 diagnostic(bool, UseNewCode3, false, \
3391 "Testing Only: Use the new version while testing") \
3392 \
3393 /* flags for performance data collection */ \
3394 \
3395 product(bool, UsePerfData, true, \
3396 "Flag to disable jvmstat instrumentation for performance testing" \
3397 "and problem isolation purposes.") \
3398 \
3399 product(bool, PerfDataSaveToFile, false, \
3400 "Save PerfData memory to hsperfdata_<pid> file on exit") \
3401 \
3402 product(ccstr, PerfDataSaveFile, NULL, \
3403 "Save PerfData memory to the specified absolute pathname," \
3404 "%p in the file name if present will be replaced by pid") \
3405 \
3406 product(intx, PerfDataSamplingInterval, 50 /*ms*/, \
3407 "Data sampling interval in milliseconds") \
3408 \
3409 develop(bool, PerfTraceDataCreation, false, \
3410 "Trace creation of Performance Data Entries") \
3411 \
3412 develop(bool, PerfTraceMemOps, false, \
3413 "Trace PerfMemory create/attach/detach calls") \
3414 \
3415 product(bool, PerfDisableSharedMem, false, \
3416 "Store performance data in standard memory") \
3417 \
3418 product(intx, PerfDataMemorySize, 32*K, \
3419 "Size of performance data memory region. Will be rounded " \
3420 "up to a multiple of the native os page size.") \
3421 \
3422 product(intx, PerfMaxStringConstLength, 1024, \
3423 "Maximum PerfStringConstant string length before truncation") \
3424 \
3425 product(bool, PerfAllowAtExitRegistration, false, \
3426 "Allow registration of atexit() methods") \
3427 \
3428 product(bool, PerfBypassFileSystemCheck, false, \
3429 "Bypass Win32 file system criteria checks (Windows Only)") \
3430 \
3431 product(intx, UnguardOnExecutionViolation, 0, \
3432 "Unguard page and retry on no-execute fault (Win32 only)" \
3433 "0=off, 1=conservative, 2=aggressive") \
3434 \
3435 /* Serviceability Support */ \
3436 \
3437 product(bool, ManagementServer, false, \
3438 "Create JMX Management Server") \
3439 \
3440 product(bool, DisableAttachMechanism, false, \
3441 "Disable mechanism that allows tools to attach to this VM") \
3442 \
3443 product(bool, StartAttachListener, false, \
3444 "Always start Attach Listener at VM startup") \
3445 \
3446 manageable(bool, PrintConcurrentLocks, false, \
3447 "Print java.util.concurrent locks in thread dump") \
3448 \
3449 /* Shared spaces */ \
3450 \
3451 product(bool, UseSharedSpaces, true, \
3452 "Use shared spaces in the permanent generation") \
3453 \
3454 product(bool, RequireSharedSpaces, false, \
3455 "Require shared spaces in the permanent generation") \
3456 \
3457 product(bool, ForceSharedSpaces, false, \
3458 "Require shared spaces in the permanent generation") \
3459 \
3460 product(bool, DumpSharedSpaces, false, \
3461 "Special mode: JVM reads a class list, loads classes, builds " \
3462 "shared spaces, and dumps the shared spaces to a file to be " \
3463 "used in future JVM runs.") \
3464 \
3465 product(bool, PrintSharedSpaces, false, \
3466 "Print usage of shared spaces") \
3467 \
3468 product(uintx, SharedDummyBlockSize, 512*M, \
3469 "Size of dummy block used to shift heap addresses (in bytes)") \
3470 \
3471 product(uintx, SharedReadWriteSize, 12*M, \
3472 "Size of read-write space in permanent generation (in bytes)") \
3473 \
3474 product(uintx, SharedReadOnlySize, 10*M, \
3475 "Size of read-only space in permanent generation (in bytes)") \
3476 \
3477 product(uintx, SharedMiscDataSize, 4*M, \
3478 "Size of the shared data area adjacent to the heap (in bytes)") \
3479 \
3480 product(uintx, SharedMiscCodeSize, 4*M, \
3481 "Size of the shared code area adjacent to the heap (in bytes)") \
3482 \
3483 diagnostic(bool, SharedOptimizeColdStart, true, \
3484 "At dump time, order shared objects to achieve better " \
3485 "cold startup time.") \
3486 \
3487 develop(intx, SharedOptimizeColdStartPolicy, 2, \
3488 "Reordering policy for SharedOptimizeColdStart " \
3489 "0=favor classload-time locality, 1=balanced, " \
3490 "2=favor runtime locality") \
3491 \
3492 diagnostic(bool, SharedSkipVerify, false, \
3493 "Skip assert() and verify() which page-in unwanted shared " \
3494 "objects. ") \
3495 \
3496 product(bool, AnonymousClasses, false, \
3497 "support sun.misc.Unsafe.defineAnonymousClass") \
3498 \
3499 experimental(bool, EnableMethodHandles, false, \
3500 "support method handles (true by default under JSR 292)") \
3501 \
3502 diagnostic(intx, MethodHandlePushLimit, 3, \
3503 "number of additional stack slots a method handle may push") \
3504 \
3505 develop(bool, TraceMethodHandles, false, \
3506 "trace internal method handle operations") \
3507 \
3508 diagnostic(bool, VerifyMethodHandles, trueInDebug, \
3509 "perform extra checks when constructing method handles") \
3510 \
3511 diagnostic(bool, OptimizeMethodHandles, true, \
3512 "when constructing method handles, try to improve them") \
3513 \
3514 experimental(bool, TrustFinalNonStaticFields, false, \
3515 "trust final non-static declarations for constant folding") \
3516 \
3517 experimental(bool, EnableInvokeDynamic, false, \
3518 "recognize the invokedynamic instruction") \
3519 \
3520 experimental(bool, AllowTransitionalJSR292, true, \
3521 "recognize pre-PFD formats of invokedynamic") \
3522 \
3523 develop(bool, TraceInvokeDynamic, false, \
3524 "trace internal invoke dynamic operations") \
3525 \
3526 diagnostic(bool, PauseAtStartup, false, \
3527 "Causes the VM to pause at startup time and wait for the pause " \
3528 "file to be removed (default: ./vm.paused.<pid>)") \
3529 \
3530 diagnostic(ccstr, PauseAtStartupFile, NULL, \
3531 "The file to create and for whose removal to await when pausing " \
3532 "at startup. (default: ./vm.paused.<pid>)") \
3533 \
3534 product(bool, ExtendedDTraceProbes, false, \
3535 "Enable performance-impacting dtrace probes") \
3536 \
3537 product(bool, DTraceMethodProbes, false, \
3538 "Enable dtrace probes for method-entry and method-exit") \
3539 \
3540 product(bool, DTraceAllocProbes, false, \
3541 "Enable dtrace probes for object allocation") \
3542 \
3543 product(bool, DTraceMonitorProbes, false, \
3544 "Enable dtrace probes for monitor events") \
3545 \
3546 product(bool, RelaxAccessControlCheck, false, \
3547 "Relax the access control checks in the verifier") \
3548 \
3549 diagnostic(bool, PrintDTraceDOF, false, \
3550 "Print the DTrace DOF passed to the system for JSDT probes") \
3551 \
3552 product(bool, UseVMInterruptibleIO, false, \
3553 "(Unstable, Solaris-specific) Thread interrupt before or with " \
3554 "EINTR for I/O operations results in OS_INTRPT. The default value"\
3555 " of this flag is true for JDK 6 and earliers")
3557 /*
3558 * Macros for factoring of globals
3559 */
3561 // Interface macros
3562 #define DECLARE_PRODUCT_FLAG(type, name, value, doc) extern "C" type name;
3563 #define DECLARE_PD_PRODUCT_FLAG(type, name, doc) extern "C" type name;
3564 #define DECLARE_DIAGNOSTIC_FLAG(type, name, value, doc) extern "C" type name;
3565 #define DECLARE_EXPERIMENTAL_FLAG(type, name, value, doc) extern "C" type name;
3566 #define DECLARE_MANAGEABLE_FLAG(type, name, value, doc) extern "C" type name;
3567 #define DECLARE_PRODUCT_RW_FLAG(type, name, value, doc) extern "C" type name;
3568 #ifdef PRODUCT
3569 #define DECLARE_DEVELOPER_FLAG(type, name, value, doc) const type name = value;
3570 #define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) const type name = pd_##name;
3571 #define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc)
3572 #else
3573 #define DECLARE_DEVELOPER_FLAG(type, name, value, doc) extern "C" type name;
3574 #define DECLARE_PD_DEVELOPER_FLAG(type, name, doc) extern "C" type name;
3575 #define DECLARE_NOTPRODUCT_FLAG(type, name, value, doc) extern "C" type name;
3576 #endif
3577 // Special LP64 flags, product only needed for now.
3578 #ifdef _LP64
3579 #define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) extern "C" type name;
3580 #else
3581 #define DECLARE_LP64_PRODUCT_FLAG(type, name, value, doc) const type name = value;
3582 #endif // _LP64
3584 // Implementation macros
3585 #define MATERIALIZE_PRODUCT_FLAG(type, name, value, doc) type name = value;
3586 #define MATERIALIZE_PD_PRODUCT_FLAG(type, name, doc) type name = pd_##name;
3587 #define MATERIALIZE_DIAGNOSTIC_FLAG(type, name, value, doc) type name = value;
3588 #define MATERIALIZE_EXPERIMENTAL_FLAG(type, name, value, doc) type name = value;
3589 #define MATERIALIZE_MANAGEABLE_FLAG(type, name, value, doc) type name = value;
3590 #define MATERIALIZE_PRODUCT_RW_FLAG(type, name, value, doc) type name = value;
3591 #ifdef PRODUCT
3592 #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) /* flag name is constant */
3593 #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) /* flag name is constant */
3594 #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc)
3595 #else
3596 #define MATERIALIZE_DEVELOPER_FLAG(type, name, value, doc) type name = value;
3597 #define MATERIALIZE_PD_DEVELOPER_FLAG(type, name, doc) type name = pd_##name;
3598 #define MATERIALIZE_NOTPRODUCT_FLAG(type, name, value, doc) type name = value;
3599 #endif
3600 #ifdef _LP64
3601 #define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) type name = value;
3602 #else
3603 #define MATERIALIZE_LP64_PRODUCT_FLAG(type, name, value, doc) /* flag is constant */
3604 #endif // _LP64
3606 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)
3608 RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_NOTPRODUCT_FLAG)
