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