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