Mercurial > hg > truffle
annotate src/share/vm/runtime/arguments.cpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
| author | tschatzl |
|---|---|
| date | Wed, 11 Sep 2013 16:25:02 +0200 |
| parents | 7944aba7ba41 |
| children | 06ae47d9d088 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7461
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:
1506
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
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:
1506
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/javaAssertions.hpp" | |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6928
diff
changeset
|
27 #include "classfile/symbolTable.hpp" |
| 1972 | 28 #include "compiler/compilerOracle.hpp" |
| 29 #include "memory/allocation.inline.hpp" | |
| 30 #include "memory/cardTableRS.hpp" | |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
31 #include "memory/genCollectedHeap.hpp" |
| 1972 | 32 #include "memory/referenceProcessor.hpp" |
| 33 #include "memory/universe.inline.hpp" | |
| 34 #include "oops/oop.inline.hpp" | |
| 35 #include "prims/jvmtiExport.hpp" | |
| 36 #include "runtime/arguments.hpp" | |
| 37 #include "runtime/globals_extension.hpp" | |
| 38 #include "runtime/java.hpp" | |
| 39 #include "services/management.hpp" | |
| 6197 | 40 #include "services/memTracker.hpp" |
| 1972 | 41 #include "utilities/defaultStream.hpp" |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
42 #include "utilities/macros.hpp" |
| 1972 | 43 #include "utilities/taskqueue.hpp" |
| 44 #ifdef TARGET_OS_FAMILY_linux | |
| 45 # include "os_linux.inline.hpp" | |
| 46 #endif | |
| 47 #ifdef TARGET_OS_FAMILY_solaris | |
| 48 # include "os_solaris.inline.hpp" | |
| 49 #endif | |
| 50 #ifdef TARGET_OS_FAMILY_windows | |
| 51 # include "os_windows.inline.hpp" | |
| 52 #endif | |
| 3960 | 53 #ifdef TARGET_OS_FAMILY_bsd |
| 54 # include "os_bsd.inline.hpp" | |
| 55 #endif | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
56 #if INCLUDE_ALL_GCS |
| 1972 | 57 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp" |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
58 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
59 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
60 #endif // INCLUDE_ALL_GCS |
| 0 | 61 |
| 2474 | 62 // Note: This is a special bug reporting site for the JVM |
| 63 #define DEFAULT_VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/crash.jsp" | |
| 0 | 64 #define DEFAULT_JAVA_LAUNCHER "generic" |
| 65 | |
|
11999
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
66 // Disable options not supported in this release, with a warning if they |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
67 // were explicitly requested on the command-line |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
68 #define UNSUPPORTED_OPTION(opt, description) \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
69 do { \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
70 if (opt) { \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
71 if (FLAG_IS_CMDLINE(opt)) { \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
72 warning(description " is disabled in this release."); \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
73 } \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
74 FLAG_SET_DEFAULT(opt, false); \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
75 } \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
76 } while(0) |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
77 |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
78 #define UNSUPPORTED_GC_OPTION(gc) \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
79 do { \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
80 if (gc) { \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
81 if (FLAG_IS_CMDLINE(gc)) { \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
82 warning(#gc " is not supported in this VM. Using Serial GC."); \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
83 } \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
84 FLAG_SET_DEFAULT(gc, false); \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
85 } \ |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
86 } while(0) |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
87 |
| 0 | 88 char** Arguments::_jvm_flags_array = NULL; |
| 89 int Arguments::_num_jvm_flags = 0; | |
| 90 char** Arguments::_jvm_args_array = NULL; | |
| 91 int Arguments::_num_jvm_args = 0; | |
| 92 char* Arguments::_java_command = NULL; | |
| 93 SystemProperty* Arguments::_system_properties = NULL; | |
| 94 const char* Arguments::_gc_log_filename = NULL; | |
| 95 bool Arguments::_has_profile = false; | |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
96 size_t Arguments::_conservative_max_heap_alignment = 0; |
| 0 | 97 uintx Arguments::_min_heap_size = 0; |
| 98 Arguments::Mode Arguments::_mode = _mixed; | |
| 99 bool Arguments::_java_compiler = false; | |
| 100 bool Arguments::_xdebug_mode = false; | |
| 101 const char* Arguments::_java_vendor_url_bug = DEFAULT_VENDOR_URL_BUG; | |
| 102 const char* Arguments::_sun_java_launcher = DEFAULT_JAVA_LAUNCHER; | |
| 103 int Arguments::_sun_java_launcher_pid = -1; | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
104 bool Arguments::_created_by_gamma_launcher = false; |
| 0 | 105 |
| 106 // These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*) | |
| 107 bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods; | |
| 108 bool Arguments::_UseOnStackReplacement = UseOnStackReplacement; | |
| 109 bool Arguments::_BackgroundCompilation = BackgroundCompilation; | |
| 110 bool Arguments::_ClipInlining = ClipInlining; | |
| 111 | |
| 112 char* Arguments::SharedArchivePath = NULL; | |
| 113 | |
| 114 AgentLibraryList Arguments::_libraryList; | |
| 115 AgentLibraryList Arguments::_agentList; | |
| 116 | |
| 117 abort_hook_t Arguments::_abort_hook = NULL; | |
| 118 exit_hook_t Arguments::_exit_hook = NULL; | |
| 119 vfprintf_hook_t Arguments::_vfprintf_hook = NULL; | |
| 120 | |
| 121 | |
| 122 SystemProperty *Arguments::_java_ext_dirs = NULL; | |
| 123 SystemProperty *Arguments::_java_endorsed_dirs = NULL; | |
| 124 SystemProperty *Arguments::_sun_boot_library_path = NULL; | |
| 125 SystemProperty *Arguments::_java_library_path = NULL; | |
| 126 SystemProperty *Arguments::_java_home = NULL; | |
| 127 SystemProperty *Arguments::_java_class_path = NULL; | |
| 128 SystemProperty *Arguments::_sun_boot_class_path = NULL; | |
| 129 | |
| 130 char* Arguments::_meta_index_path = NULL; | |
| 131 char* Arguments::_meta_index_dir = NULL; | |
| 132 | |
| 133 // Check if head of 'option' matches 'name', and sets 'tail' remaining part of option string | |
| 134 | |
| 135 static bool match_option(const JavaVMOption *option, const char* name, | |
| 136 const char** tail) { | |
| 137 int len = (int)strlen(name); | |
| 138 if (strncmp(option->optionString, name, len) == 0) { | |
| 139 *tail = option->optionString + len; | |
| 140 return true; | |
| 141 } else { | |
| 142 return false; | |
| 143 } | |
| 144 } | |
| 145 | |
| 146 static void logOption(const char* opt) { | |
| 147 if (PrintVMOptions) { | |
| 148 jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt); | |
| 149 } | |
| 150 } | |
| 151 | |
| 152 // Process java launcher properties. | |
| 153 void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) { | |
| 154 // See if sun.java.launcher or sun.java.launcher.pid is defined. | |
| 155 // Must do this before setting up other system properties, | |
| 156 // as some of them may depend on launcher type. | |
| 157 for (int index = 0; index < args->nOptions; index++) { | |
| 158 const JavaVMOption* option = args->options + index; | |
| 159 const char* tail; | |
| 160 | |
| 161 if (match_option(option, "-Dsun.java.launcher=", &tail)) { | |
| 162 process_java_launcher_argument(tail, option->extraInfo); | |
| 163 continue; | |
| 164 } | |
| 165 if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) { | |
| 166 _sun_java_launcher_pid = atoi(tail); | |
| 167 continue; | |
| 168 } | |
| 169 } | |
| 170 } | |
| 171 | |
| 172 // Initialize system properties key and value. | |
| 173 void Arguments::init_system_properties() { | |
| 174 | |
| 175 PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name", | |
| 176 "Java Virtual Machine Specification", false)); | |
| 177 PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(), false)); | |
| 178 PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(), false)); | |
| 179 PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(), true)); | |
| 180 | |
| 181 // following are JVMTI agent writeable properties. | |
| 182 // Properties values are set to NULL and they are | |
| 183 // os specific they are initialized in os::init_system_properties_values(). | |
| 184 _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL, true); | |
| 185 _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL, true); | |
| 186 _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL, true); | |
| 187 _java_library_path = new SystemProperty("java.library.path", NULL, true); | |
| 188 _java_home = new SystemProperty("java.home", NULL, true); | |
| 189 _sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL, true); | |
| 190 | |
| 191 _java_class_path = new SystemProperty("java.class.path", "", true); | |
| 192 | |
| 193 // Add to System Property list. | |
| 194 PropertyList_add(&_system_properties, _java_ext_dirs); | |
| 195 PropertyList_add(&_system_properties, _java_endorsed_dirs); | |
| 196 PropertyList_add(&_system_properties, _sun_boot_library_path); | |
| 197 PropertyList_add(&_system_properties, _java_library_path); | |
| 198 PropertyList_add(&_system_properties, _java_home); | |
| 199 PropertyList_add(&_system_properties, _java_class_path); | |
| 200 PropertyList_add(&_system_properties, _sun_boot_class_path); | |
| 201 | |
| 202 // Set OS specific system properties values | |
| 203 os::init_system_properties_values(); | |
| 204 } | |
| 205 | |
|
1864
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
206 |
|
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
207 // Update/Initialize System properties after JDK version number is known |
|
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
208 void Arguments::init_version_specific_system_properties() { |
|
1956
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
209 enum { bufsz = 16 }; |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
210 char buffer[bufsz]; |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
211 const char* spec_vendor = "Sun Microsystems Inc."; |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
212 uint32_t spec_version = 0; |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
213 |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
214 if (JDK_Version::is_gte_jdk17x_version()) { |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
215 spec_vendor = "Oracle Corporation"; |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
216 spec_version = JDK_Version::current().major_version(); |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
217 } |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
218 jio_snprintf(buffer, bufsz, "1." UINT32_FORMAT, spec_version); |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
219 |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
220 PropertyList_add(&_system_properties, |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
221 new SystemProperty("java.vm.specification.vendor", spec_vendor, false)); |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
222 PropertyList_add(&_system_properties, |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
223 new SystemProperty("java.vm.specification.version", buffer, false)); |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
224 PropertyList_add(&_system_properties, |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
225 new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(), false)); |
|
1864
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
226 } |
|
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
227 |
| 242 | 228 /** |
| 229 * Provide a slightly more user-friendly way of eliminating -XX flags. | |
| 230 * When a flag is eliminated, it can be added to this list in order to | |
| 231 * continue accepting this flag on the command-line, while issuing a warning | |
| 232 * and ignoring the value. Once the JDK version reaches the 'accept_until' | |
| 233 * limit, we flatly refuse to admit the existence of the flag. This allows | |
| 234 * a flag to die correctly over JDK releases using HSX. | |
| 235 */ | |
| 236 typedef struct { | |
| 237 const char* name; | |
| 238 JDK_Version obsoleted_in; // when the flag went away | |
| 239 JDK_Version accept_until; // which version to start denying the existence | |
| 240 } ObsoleteFlag; | |
| 0 | 241 |
| 242 | 242 static ObsoleteFlag obsolete_jvm_flags[] = { |
| 243 { "UseTrainGC", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 244 { "UseSpecialLargeObjectHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 245 { "UseOversizedCarHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 246 { "TraceCarAllocation", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 247 { "PrintTrainGCProcessingStats", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 248 { "LogOfCarSpaceSize", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 249 { "OversizedCarThreshold", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 250 { "MinTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 251 { "DefaultTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 252 { "MaxTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 253 { "DelayTickAdjustment", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 254 { "ProcessingToTenuringRatio", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 255 { "MinTrainLength", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 256 { "AppendRatio", JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) }, | |
| 1064 | 257 { "DefaultMaxRAM", JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) }, |
| 258 { "DefaultInitialRAMFraction", | |
| 259 JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) }, | |
|
1706
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1628
diff
changeset
|
260 { "UseDepthFirstScavengeOrder", |
|
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1628
diff
changeset
|
261 JDK_Version::jdk_update(6,22), JDK_Version::jdk(7) }, |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1832
diff
changeset
|
262 { "HandlePromotionFailure", |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1832
diff
changeset
|
263 JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) }, |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1832
diff
changeset
|
264 { "MaxLiveObjectEvacuationRatio", |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1832
diff
changeset
|
265 JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) }, |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
266 { "ForceSharedSpaces", JDK_Version::jdk_update(6,25), JDK_Version::jdk(8) }, |
|
3251
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
3250
diff
changeset
|
267 { "UseParallelOldGCCompacting", |
|
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
3250
diff
changeset
|
268 JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) }, |
|
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
3250
diff
changeset
|
269 { "UseParallelDensePrefixUpdate", |
|
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
3250
diff
changeset
|
270 JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) }, |
|
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
3250
diff
changeset
|
271 { "UseParallelOldGCDensePrefix", |
|
eda9eb483d29
6841742: par compact - remove unused/unsupported options
jcoomes
parents:
3250
diff
changeset
|
272 JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) }, |
| 2460 | 273 { "AllowTransitionalJSR292", JDK_Version::jdk(7), JDK_Version::jdk(8) }, |
|
3797
eb94b7226b7a
7061192: option handling adjustments for oracle and embedded builds
jcoomes
parents:
3769
diff
changeset
|
274 { "UseCompressedStrings", JDK_Version::jdk(7), JDK_Version::jdk(8) }, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
275 { "CMSPermGenPrecleaningEnabled", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
276 { "CMSTriggerPermRatio", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
277 { "CMSInitiatingPermOccupancyFraction", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
278 { "AdaptivePermSizeWeight", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
279 { "PermGenPadding", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
280 { "PermMarkSweepDeadRatio", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
281 { "PermSize", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
282 { "MaxPermSize", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
283 { "MinPermHeapExpansion", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
284 { "MaxPermHeapExpansion", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
285 { "CMSRevisitStackSize", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
286 { "PrintRevisitStats", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
| 6916 | 287 { "UseVectoredExceptions", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
8819
36376b540a98
8009595: The UseSplitVerifier option needs to be deprecated.
hseigel
parents:
8746
diff
changeset
|
288 { "UseSplitVerifier", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
11111
dec841e0c9aa
8016749: -XX:+UseISM fails an assert(obj->is_oop()) when running SPECjbb2005
anoll
parents:
11109
diff
changeset
|
289 { "UseISM", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
dec841e0c9aa
8016749: -XX:+UseISM fails an assert(obj->is_oop()) when running SPECjbb2005
anoll
parents:
11109
diff
changeset
|
290 { "UsePermISM", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
dec841e0c9aa
8016749: -XX:+UseISM fails an assert(obj->is_oop()) when running SPECjbb2005
anoll
parents:
11109
diff
changeset
|
291 { "UseMPSS", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
11154
02d7aa1456c9
8004872: Early loading of HashMap and StringValue under -XX:+AggressiveOpts can be removed
ccheung
parents:
11112
diff
changeset
|
292 { "UseStringCache", JDK_Version::jdk(8), JDK_Version::jdk(9) }, |
|
3797
eb94b7226b7a
7061192: option handling adjustments for oracle and embedded builds
jcoomes
parents:
3769
diff
changeset
|
293 #ifdef PRODUCT |
|
eb94b7226b7a
7061192: option handling adjustments for oracle and embedded builds
jcoomes
parents:
3769
diff
changeset
|
294 { "DesiredMethodLimit", |
|
eb94b7226b7a
7061192: option handling adjustments for oracle and embedded builds
jcoomes
parents:
3769
diff
changeset
|
295 JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) }, |
|
eb94b7226b7a
7061192: option handling adjustments for oracle and embedded builds
jcoomes
parents:
3769
diff
changeset
|
296 #endif // PRODUCT |
| 242 | 297 { NULL, JDK_Version(0), JDK_Version(0) } |
| 298 }; | |
| 299 | |
| 300 // Returns true if the flag is obsolete and fits into the range specified | |
| 301 // for being ignored. In the case that the flag is ignored, the 'version' | |
| 302 // value is filled in with the version number when the flag became | |
| 303 // obsolete so that that value can be displayed to the user. | |
| 304 bool Arguments::is_newly_obsolete(const char *s, JDK_Version* version) { | |
| 0 | 305 int i = 0; |
| 242 | 306 assert(version != NULL, "Must provide a version buffer"); |
| 307 while (obsolete_jvm_flags[i].name != NULL) { | |
| 308 const ObsoleteFlag& flag_status = obsolete_jvm_flags[i]; | |
| 0 | 309 // <flag>=xxx form |
| 310 // [-|+]<flag> form | |
| 242 | 311 if ((strncmp(flag_status.name, s, strlen(flag_status.name)) == 0) || |
| 0 | 312 ((s[0] == '+' || s[0] == '-') && |
| 242 | 313 (strncmp(flag_status.name, &s[1], strlen(flag_status.name)) == 0))) { |
| 314 if (JDK_Version::current().compare(flag_status.accept_until) == -1) { | |
| 315 *version = flag_status.obsoleted_in; | |
| 316 return true; | |
| 317 } | |
| 0 | 318 } |
| 319 i++; | |
| 320 } | |
| 321 return false; | |
| 322 } | |
| 323 | |
| 324 // Constructs the system class path (aka boot class path) from the following | |
| 325 // components, in order: | |
| 326 // | |
| 327 // prefix // from -Xbootclasspath/p:... | |
| 328 // endorsed // the expansion of -Djava.endorsed.dirs=... | |
| 329 // base // from os::get_system_properties() or -Xbootclasspath= | |
| 330 // suffix // from -Xbootclasspath/a:... | |
| 331 // | |
| 332 // java.endorsed.dirs is a list of directories; any jar or zip files in the | |
| 333 // directories are added to the sysclasspath just before the base. | |
| 334 // | |
| 335 // This could be AllStatic, but it isn't needed after argument processing is | |
| 336 // complete. | |
| 337 class SysClassPath: public StackObj { | |
| 338 public: | |
| 339 SysClassPath(const char* base); | |
| 340 ~SysClassPath(); | |
| 341 | |
| 342 inline void set_base(const char* base); | |
| 343 inline void add_prefix(const char* prefix); | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
344 inline void add_suffix_to_prefix(const char* suffix); |
| 0 | 345 inline void add_suffix(const char* suffix); |
| 346 inline void reset_path(const char* base); | |
| 347 | |
| 348 // Expand the jar/zip files in each directory listed by the java.endorsed.dirs | |
| 349 // property. Must be called after all command-line arguments have been | |
| 350 // processed (in particular, -Djava.endorsed.dirs=...) and before calling | |
| 351 // combined_path(). | |
| 352 void expand_endorsed(); | |
| 353 | |
| 354 inline const char* get_base() const { return _items[_scp_base]; } | |
| 355 inline const char* get_prefix() const { return _items[_scp_prefix]; } | |
| 356 inline const char* get_suffix() const { return _items[_scp_suffix]; } | |
| 357 inline const char* get_endorsed() const { return _items[_scp_endorsed]; } | |
| 358 | |
| 359 // Combine all the components into a single c-heap-allocated string; caller | |
| 360 // must free the string if/when no longer needed. | |
| 361 char* combined_path(); | |
| 362 | |
| 363 private: | |
| 364 // Utility routines. | |
| 365 static char* add_to_path(const char* path, const char* str, bool prepend); | |
| 366 static char* add_jars_to_path(char* path, const char* directory); | |
| 367 | |
| 368 inline void reset_item_at(int index); | |
| 369 | |
| 370 // Array indices for the items that make up the sysclasspath. All except the | |
| 371 // base are allocated in the C heap and freed by this class. | |
| 372 enum { | |
| 373 _scp_prefix, // from -Xbootclasspath/p:... | |
| 374 _scp_endorsed, // the expansion of -Djava.endorsed.dirs=... | |
| 375 _scp_base, // the default sysclasspath | |
| 376 _scp_suffix, // from -Xbootclasspath/a:... | |
| 377 _scp_nitems // the number of items, must be last. | |
| 378 }; | |
| 379 | |
| 380 const char* _items[_scp_nitems]; | |
| 381 DEBUG_ONLY(bool _expansion_done;) | |
| 382 }; | |
| 383 | |
| 384 SysClassPath::SysClassPath(const char* base) { | |
| 385 memset(_items, 0, sizeof(_items)); | |
| 386 _items[_scp_base] = base; | |
| 387 DEBUG_ONLY(_expansion_done = false;) | |
| 388 } | |
| 389 | |
| 390 SysClassPath::~SysClassPath() { | |
| 391 // Free everything except the base. | |
| 392 for (int i = 0; i < _scp_nitems; ++i) { | |
| 393 if (i != _scp_base) reset_item_at(i); | |
| 394 } | |
| 395 DEBUG_ONLY(_expansion_done = false;) | |
| 396 } | |
| 397 | |
| 398 inline void SysClassPath::set_base(const char* base) { | |
| 399 _items[_scp_base] = base; | |
| 400 } | |
| 401 | |
| 402 inline void SysClassPath::add_prefix(const char* prefix) { | |
| 403 _items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true); | |
| 404 } | |
| 405 | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
406 inline void SysClassPath::add_suffix_to_prefix(const char* suffix) { |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
407 _items[_scp_prefix] = add_to_path(_items[_scp_prefix], suffix, false); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
408 } |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
409 |
| 0 | 410 inline void SysClassPath::add_suffix(const char* suffix) { |
| 411 _items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false); | |
| 412 } | |
| 413 | |
| 414 inline void SysClassPath::reset_item_at(int index) { | |
| 415 assert(index < _scp_nitems && index != _scp_base, "just checking"); | |
| 416 if (_items[index] != NULL) { | |
| 6197 | 417 FREE_C_HEAP_ARRAY(char, _items[index], mtInternal); |
| 0 | 418 _items[index] = NULL; |
| 419 } | |
| 420 } | |
| 421 | |
| 422 inline void SysClassPath::reset_path(const char* base) { | |
| 423 // Clear the prefix and suffix. | |
| 424 reset_item_at(_scp_prefix); | |
| 425 reset_item_at(_scp_suffix); | |
| 426 set_base(base); | |
| 427 } | |
| 428 | |
| 429 //------------------------------------------------------------------------------ | |
| 430 | |
| 431 void SysClassPath::expand_endorsed() { | |
| 432 assert(_items[_scp_endorsed] == NULL, "can only be called once."); | |
| 433 | |
| 434 const char* path = Arguments::get_property("java.endorsed.dirs"); | |
| 435 if (path == NULL) { | |
| 436 path = Arguments::get_endorsed_dir(); | |
| 437 assert(path != NULL, "no default for java.endorsed.dirs"); | |
| 438 } | |
| 439 | |
| 440 char* expanded_path = NULL; | |
| 441 const char separator = *os::path_separator(); | |
| 442 const char* const end = path + strlen(path); | |
| 443 while (path < end) { | |
| 444 const char* tmp_end = strchr(path, separator); | |
| 445 if (tmp_end == NULL) { | |
| 446 expanded_path = add_jars_to_path(expanded_path, path); | |
| 447 path = end; | |
| 448 } else { | |
| 6197 | 449 char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal); |
| 0 | 450 memcpy(dirpath, path, tmp_end - path); |
| 451 dirpath[tmp_end - path] = '\0'; | |
| 452 expanded_path = add_jars_to_path(expanded_path, dirpath); | |
| 6197 | 453 FREE_C_HEAP_ARRAY(char, dirpath, mtInternal); |
| 0 | 454 path = tmp_end + 1; |
| 455 } | |
| 456 } | |
| 457 _items[_scp_endorsed] = expanded_path; | |
| 458 DEBUG_ONLY(_expansion_done = true;) | |
| 459 } | |
| 460 | |
| 461 // Combine the bootclasspath elements, some of which may be null, into a single | |
| 462 // c-heap-allocated string. | |
| 463 char* SysClassPath::combined_path() { | |
| 464 assert(_items[_scp_base] != NULL, "empty default sysclasspath"); | |
| 465 assert(_expansion_done, "must call expand_endorsed() first."); | |
| 466 | |
| 467 size_t lengths[_scp_nitems]; | |
| 468 size_t total_len = 0; | |
| 469 | |
| 470 const char separator = *os::path_separator(); | |
| 471 | |
| 472 // Get the lengths. | |
| 473 int i; | |
| 474 for (i = 0; i < _scp_nitems; ++i) { | |
| 475 if (_items[i] != NULL) { | |
| 476 lengths[i] = strlen(_items[i]); | |
| 477 // Include space for the separator char (or a NULL for the last item). | |
| 478 total_len += lengths[i] + 1; | |
| 479 } | |
| 480 } | |
| 481 assert(total_len > 0, "empty sysclasspath not allowed"); | |
| 482 | |
| 483 // Copy the _items to a single string. | |
| 6197 | 484 char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal); |
| 0 | 485 char* cp_tmp = cp; |
| 486 for (i = 0; i < _scp_nitems; ++i) { | |
| 487 if (_items[i] != NULL) { | |
| 488 memcpy(cp_tmp, _items[i], lengths[i]); | |
| 489 cp_tmp += lengths[i]; | |
| 490 *cp_tmp++ = separator; | |
| 491 } | |
| 492 } | |
| 493 *--cp_tmp = '\0'; // Replace the extra separator. | |
| 494 return cp; | |
| 495 } | |
| 496 | |
| 497 // Note: path must be c-heap-allocated (or NULL); it is freed if non-null. | |
| 498 char* | |
| 499 SysClassPath::add_to_path(const char* path, const char* str, bool prepend) { | |
| 500 char *cp; | |
| 501 | |
| 502 assert(str != NULL, "just checking"); | |
| 503 if (path == NULL) { | |
| 504 size_t len = strlen(str) + 1; | |
| 6197 | 505 cp = NEW_C_HEAP_ARRAY(char, len, mtInternal); |
| 0 | 506 memcpy(cp, str, len); // copy the trailing null |
| 507 } else { | |
| 508 const char separator = *os::path_separator(); | |
| 509 size_t old_len = strlen(path); | |
| 510 size_t str_len = strlen(str); | |
| 511 size_t len = old_len + str_len + 2; | |
| 512 | |
| 513 if (prepend) { | |
| 6197 | 514 cp = NEW_C_HEAP_ARRAY(char, len, mtInternal); |
| 0 | 515 char* cp_tmp = cp; |
| 516 memcpy(cp_tmp, str, str_len); | |
| 517 cp_tmp += str_len; | |
| 518 *cp_tmp = separator; | |
| 519 memcpy(++cp_tmp, path, old_len + 1); // copy the trailing null | |
| 6197 | 520 FREE_C_HEAP_ARRAY(char, path, mtInternal); |
| 0 | 521 } else { |
| 6197 | 522 cp = REALLOC_C_HEAP_ARRAY(char, path, len, mtInternal); |
| 0 | 523 char* cp_tmp = cp + old_len; |
| 524 *cp_tmp = separator; | |
| 525 memcpy(++cp_tmp, str, str_len + 1); // copy the trailing null | |
| 526 } | |
| 527 } | |
| 528 return cp; | |
| 529 } | |
| 530 | |
| 531 // Scan the directory and append any jar or zip files found to path. | |
| 532 // Note: path must be c-heap-allocated (or NULL); it is freed if non-null. | |
| 533 char* SysClassPath::add_jars_to_path(char* path, const char* directory) { | |
| 534 DIR* dir = os::opendir(directory); | |
| 535 if (dir == NULL) return path; | |
| 536 | |
| 537 char dir_sep[2] = { '\0', '\0' }; | |
| 538 size_t directory_len = strlen(directory); | |
| 539 const char fileSep = *os::file_separator(); | |
| 540 if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep; | |
| 541 | |
| 542 /* Scan the directory for jars/zips, appending them to path. */ | |
| 543 struct dirent *entry; | |
| 6197 | 544 char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory), mtInternal); |
| 0 | 545 while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) { |
| 546 const char* name = entry->d_name; | |
| 547 const char* ext = name + strlen(name) - 4; | |
| 548 bool isJarOrZip = ext > name && | |
| 549 (os::file_name_strcmp(ext, ".jar") == 0 || | |
| 550 os::file_name_strcmp(ext, ".zip") == 0); | |
| 551 if (isJarOrZip) { | |
| 6197 | 552 char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name), mtInternal); |
| 0 | 553 sprintf(jarpath, "%s%s%s", directory, dir_sep, name); |
| 554 path = add_to_path(path, jarpath, false); | |
| 6197 | 555 FREE_C_HEAP_ARRAY(char, jarpath, mtInternal); |
| 0 | 556 } |
| 557 } | |
| 6197 | 558 FREE_C_HEAP_ARRAY(char, dbuf, mtInternal); |
| 0 | 559 os::closedir(dir); |
| 560 return path; | |
| 561 } | |
| 562 | |
| 563 // Parses a memory size specification string. | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
564 static bool atomull(const char *s, julong* result) { |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
565 julong n = 0; |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7461
diff
changeset
|
566 int args_read = sscanf(s, JULONG_FORMAT, &n); |
| 0 | 567 if (args_read != 1) { |
| 568 return false; | |
| 569 } | |
| 570 while (*s != '\0' && isdigit(*s)) { | |
| 571 s++; | |
| 572 } | |
| 573 // 4705540: illegal if more characters are found after the first non-digit | |
| 574 if (strlen(s) > 1) { | |
| 575 return false; | |
| 576 } | |
| 577 switch (*s) { | |
| 578 case 'T': case 't': | |
| 579 *result = n * G * K; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
580 // Check for overflow. |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
581 if (*result/((julong)G * K) != n) return false; |
| 0 | 582 return true; |
| 583 case 'G': case 'g': | |
| 584 *result = n * G; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
585 if (*result/G != n) return false; |
| 0 | 586 return true; |
| 587 case 'M': case 'm': | |
| 588 *result = n * M; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
589 if (*result/M != n) return false; |
| 0 | 590 return true; |
| 591 case 'K': case 'k': | |
| 592 *result = n * K; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
593 if (*result/K != n) return false; |
| 0 | 594 return true; |
| 595 case '\0': | |
| 596 *result = n; | |
| 597 return true; | |
| 598 default: | |
| 599 return false; | |
| 600 } | |
| 601 } | |
| 602 | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
603 Arguments::ArgsRange Arguments::check_memory_size(julong size, julong min_size) { |
| 0 | 604 if (size < min_size) return arg_too_small; |
| 605 // Check that size will fit in a size_t (only relevant on 32-bit) | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
606 if (size > max_uintx) return arg_too_big; |
| 0 | 607 return arg_in_range; |
| 608 } | |
| 609 | |
| 610 // Describe an argument out of range error | |
| 611 void Arguments::describe_range_error(ArgsRange errcode) { | |
| 612 switch(errcode) { | |
| 613 case arg_too_big: | |
| 614 jio_fprintf(defaultStream::error_stream(), | |
| 615 "The specified size exceeds the maximum " | |
| 616 "representable size.\n"); | |
| 617 break; | |
| 618 case arg_too_small: | |
| 619 case arg_unreadable: | |
| 620 case arg_in_range: | |
| 621 // do nothing for now | |
| 622 break; | |
| 623 default: | |
| 624 ShouldNotReachHere(); | |
| 625 } | |
| 626 } | |
| 627 | |
| 628 static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) { | |
| 629 return CommandLineFlags::boolAtPut(name, &value, origin); | |
| 630 } | |
| 631 | |
| 632 static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) { | |
| 633 double v; | |
| 634 if (sscanf(value, "%lf", &v) != 1) { | |
| 635 return false; | |
| 636 } | |
| 637 | |
| 638 if (CommandLineFlags::doubleAtPut(name, &v, origin)) { | |
| 639 return true; | |
| 640 } | |
| 641 return false; | |
| 642 } | |
| 643 | |
| 644 static bool set_numeric_flag(char* name, char* value, FlagValueOrigin origin) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
645 julong v; |
| 0 | 646 intx intx_v; |
| 647 bool is_neg = false; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
648 // Check the sign first since atomull() parses only unsigned values. |
| 0 | 649 if (*value == '-') { |
| 650 if (!CommandLineFlags::intxAt(name, &intx_v)) { | |
| 651 return false; | |
| 652 } | |
| 653 value++; | |
| 654 is_neg = true; | |
| 655 } | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
656 if (!atomull(value, &v)) { |
| 0 | 657 return false; |
| 658 } | |
| 659 intx_v = (intx) v; | |
| 660 if (is_neg) { | |
| 661 intx_v = -intx_v; | |
| 662 } | |
| 663 if (CommandLineFlags::intxAtPut(name, &intx_v, origin)) { | |
| 664 return true; | |
| 665 } | |
| 666 uintx uintx_v = (uintx) v; | |
| 667 if (!is_neg && CommandLineFlags::uintxAtPut(name, &uintx_v, origin)) { | |
| 668 return true; | |
| 669 } | |
| 1064 | 670 uint64_t uint64_t_v = (uint64_t) v; |
| 671 if (!is_neg && CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin)) { | |
| 672 return true; | |
| 673 } | |
| 0 | 674 return false; |
| 675 } | |
| 676 | |
| 677 static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) { | |
| 678 if (!CommandLineFlags::ccstrAtPut(name, &value, origin)) return false; | |
| 679 // Contract: CommandLineFlags always returns a pointer that needs freeing. | |
| 6197 | 680 FREE_C_HEAP_ARRAY(char, value, mtInternal); |
| 0 | 681 return true; |
| 682 } | |
| 683 | |
| 684 static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) { | |
| 685 const char* old_value = ""; | |
| 686 if (!CommandLineFlags::ccstrAt(name, &old_value)) return false; | |
| 687 size_t old_len = old_value != NULL ? strlen(old_value) : 0; | |
| 688 size_t new_len = strlen(new_value); | |
| 689 const char* value; | |
| 690 char* free_this_too = NULL; | |
| 691 if (old_len == 0) { | |
| 692 value = new_value; | |
| 693 } else if (new_len == 0) { | |
| 694 value = old_value; | |
| 695 } else { | |
| 6197 | 696 char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1, mtInternal); |
| 0 | 697 // each new setting adds another LINE to the switch: |
| 698 sprintf(buf, "%s\n%s", old_value, new_value); | |
| 699 value = buf; | |
| 700 free_this_too = buf; | |
| 701 } | |
| 702 (void) CommandLineFlags::ccstrAtPut(name, &value, origin); | |
| 703 // CommandLineFlags always returns a pointer that needs freeing. | |
| 6197 | 704 FREE_C_HEAP_ARRAY(char, value, mtInternal); |
| 0 | 705 if (free_this_too != NULL) { |
| 706 // CommandLineFlags made its own copy, so I must delete my own temp. buffer. | |
| 6197 | 707 FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal); |
| 0 | 708 } |
| 709 return true; | |
| 710 } | |
| 711 | |
| 712 bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) { | |
| 713 | |
| 714 // range of acceptable characters spelled out for portability reasons | |
| 715 #define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]" | |
| 716 #define BUFLEN 255 | |
| 717 char name[BUFLEN+1]; | |
| 718 char dummy; | |
| 719 | |
| 720 if (sscanf(arg, "-%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) { | |
| 721 return set_bool_flag(name, false, origin); | |
| 722 } | |
| 723 if (sscanf(arg, "+%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) { | |
| 724 return set_bool_flag(name, true, origin); | |
| 725 } | |
| 726 | |
| 727 char punct; | |
| 728 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "%c", name, &punct) == 2 && punct == '=') { | |
| 729 const char* value = strchr(arg, '=') + 1; | |
| 730 Flag* flag = Flag::find_flag(name, strlen(name)); | |
| 731 if (flag != NULL && flag->is_ccstr()) { | |
| 732 if (flag->ccstr_accumulates()) { | |
| 733 return append_to_string_flag(name, value, origin); | |
| 734 } else { | |
| 735 if (value[0] == '\0') { | |
| 736 value = NULL; | |
| 737 } | |
| 738 return set_string_flag(name, value, origin); | |
| 739 } | |
| 740 } | |
| 741 } | |
| 742 | |
| 743 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE ":%c", name, &punct) == 2 && punct == '=') { | |
| 744 const char* value = strchr(arg, '=') + 1; | |
| 745 // -XX:Foo:=xxx will reset the string flag to the given value. | |
| 746 if (value[0] == '\0') { | |
| 747 value = NULL; | |
| 748 } | |
| 749 return set_string_flag(name, value, origin); | |
| 750 } | |
| 751 | |
| 752 #define SIGNED_FP_NUMBER_RANGE "[-0123456789.]" | |
| 753 #define SIGNED_NUMBER_RANGE "[-0123456789]" | |
| 754 #define NUMBER_RANGE "[0123456789]" | |
| 755 char value[BUFLEN + 1]; | |
| 756 char value2[BUFLEN + 1]; | |
| 757 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_NUMBER_RANGE "." "%" XSTR(BUFLEN) NUMBER_RANGE "%c", name, value, value2, &dummy) == 3) { | |
| 758 // Looks like a floating-point number -- try again with more lenient format string | |
| 759 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_FP_NUMBER_RANGE "%c", name, value, &dummy) == 2) { | |
| 760 return set_fp_numeric_flag(name, value, origin); | |
| 761 } | |
| 762 } | |
| 763 | |
| 764 #define VALUE_RANGE "[-kmgtKMGT0123456789]" | |
| 765 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) VALUE_RANGE "%c", name, value, &dummy) == 2) { | |
| 766 return set_numeric_flag(name, value, origin); | |
| 767 } | |
| 768 | |
| 769 return false; | |
| 770 } | |
| 771 | |
| 772 void Arguments::add_string(char*** bldarray, int* count, const char* arg) { | |
| 773 assert(bldarray != NULL, "illegal argument"); | |
| 774 | |
| 775 if (arg == NULL) { | |
| 776 return; | |
| 777 } | |
| 778 | |
|
10238
1d0fba8a2a6d
8013574: PrintMalloc conflicts with the command line parsing
brutisso
parents:
10126
diff
changeset
|
779 int new_count = *count + 1; |
| 0 | 780 |
| 781 // expand the array and add arg to the last element | |
| 782 if (*bldarray == NULL) { | |
|
10238
1d0fba8a2a6d
8013574: PrintMalloc conflicts with the command line parsing
brutisso
parents:
10126
diff
changeset
|
783 *bldarray = NEW_C_HEAP_ARRAY(char*, new_count, mtInternal); |
| 0 | 784 } else { |
|
10238
1d0fba8a2a6d
8013574: PrintMalloc conflicts with the command line parsing
brutisso
parents:
10126
diff
changeset
|
785 *bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, new_count, mtInternal); |
| 0 | 786 } |
|
10238
1d0fba8a2a6d
8013574: PrintMalloc conflicts with the command line parsing
brutisso
parents:
10126
diff
changeset
|
787 (*bldarray)[*count] = strdup(arg); |
|
1d0fba8a2a6d
8013574: PrintMalloc conflicts with the command line parsing
brutisso
parents:
10126
diff
changeset
|
788 *count = new_count; |
| 0 | 789 } |
| 790 | |
| 791 void Arguments::build_jvm_args(const char* arg) { | |
| 792 add_string(&_jvm_args_array, &_num_jvm_args, arg); | |
| 793 } | |
| 794 | |
| 795 void Arguments::build_jvm_flags(const char* arg) { | |
| 796 add_string(&_jvm_flags_array, &_num_jvm_flags, arg); | |
| 797 } | |
| 798 | |
| 799 // utility function to return a string that concatenates all | |
| 800 // strings in a given char** array | |
| 801 const char* Arguments::build_resource_string(char** args, int count) { | |
| 802 if (args == NULL || count == 0) { | |
| 803 return NULL; | |
| 804 } | |
| 805 size_t length = strlen(args[0]) + 1; // add 1 for the null terminator | |
| 806 for (int i = 1; i < count; i++) { | |
| 807 length += strlen(args[i]) + 1; // add 1 for a space | |
| 808 } | |
| 809 char* s = NEW_RESOURCE_ARRAY(char, length); | |
| 810 strcpy(s, args[0]); | |
| 811 for (int j = 1; j < count; j++) { | |
| 812 strcat(s, " "); | |
| 813 strcat(s, args[j]); | |
| 814 } | |
| 815 return (const char*) s; | |
| 816 } | |
| 817 | |
| 818 void Arguments::print_on(outputStream* st) { | |
| 819 st->print_cr("VM Arguments:"); | |
| 820 if (num_jvm_flags() > 0) { | |
| 821 st->print("jvm_flags: "); print_jvm_flags_on(st); | |
| 822 } | |
| 823 if (num_jvm_args() > 0) { | |
| 824 st->print("jvm_args: "); print_jvm_args_on(st); | |
| 825 } | |
| 826 st->print_cr("java_command: %s", java_command() ? java_command() : "<unknown>"); | |
|
6879
8ebcedb7604d
7053130: hs_err file does not record specified CLASSPATH
coleenp
parents:
6878
diff
changeset
|
827 if (_java_class_path != NULL) { |
|
8ebcedb7604d
7053130: hs_err file does not record specified CLASSPATH
coleenp
parents:
6878
diff
changeset
|
828 char* path = _java_class_path->value(); |
|
8ebcedb7604d
7053130: hs_err file does not record specified CLASSPATH
coleenp
parents:
6878
diff
changeset
|
829 st->print_cr("java_class_path (initial): %s", strlen(path) == 0 ? "<not set>" : path ); |
|
8ebcedb7604d
7053130: hs_err file does not record specified CLASSPATH
coleenp
parents:
6878
diff
changeset
|
830 } |
| 0 | 831 st->print_cr("Launcher Type: %s", _sun_java_launcher); |
| 832 } | |
| 833 | |
| 834 void Arguments::print_jvm_flags_on(outputStream* st) { | |
| 835 if (_num_jvm_flags > 0) { | |
| 836 for (int i=0; i < _num_jvm_flags; i++) { | |
| 837 st->print("%s ", _jvm_flags_array[i]); | |
| 838 } | |
| 839 st->print_cr(""); | |
| 840 } | |
| 841 } | |
| 842 | |
| 843 void Arguments::print_jvm_args_on(outputStream* st) { | |
| 844 if (_num_jvm_args > 0) { | |
| 845 for (int i=0; i < _num_jvm_args; i++) { | |
| 846 st->print("%s ", _jvm_args_array[i]); | |
| 847 } | |
| 848 st->print_cr(""); | |
| 849 } | |
| 850 } | |
| 851 | |
| 242 | 852 bool Arguments::process_argument(const char* arg, |
| 853 jboolean ignore_unrecognized, FlagValueOrigin origin) { | |
| 854 | |
| 855 JDK_Version since = JDK_Version(); | |
| 0 | 856 |
| 3250 | 857 if (parse_argument(arg, origin) || ignore_unrecognized) { |
| 858 return true; | |
| 0 | 859 } |
| 3250 | 860 |
|
7961
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
861 bool has_plus_minus = (*arg == '+' || *arg == '-'); |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
862 const char* const argname = has_plus_minus ? arg + 1 : arg; |
| 3250 | 863 if (is_newly_obsolete(arg, &since)) { |
| 864 char version[256]; | |
| 865 since.to_string(version, sizeof(version)); | |
| 866 warning("ignoring option %s; support was removed in %s", argname, version); | |
| 867 return true; | |
| 868 } | |
| 869 | |
|
5947
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
870 // For locked flags, report a custom error message if available. |
|
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
871 // Otherwise, report the standard unrecognized VM option. |
|
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
872 |
|
7961
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
873 size_t arg_len; |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
874 const char* equal_sign = strchr(argname, '='); |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
875 if (equal_sign == NULL) { |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
876 arg_len = strlen(argname); |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
877 } else { |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
878 arg_len = equal_sign - argname; |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
879 } |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
880 |
| 11070 | 881 Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, true); |
|
7961
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
882 if (found_flag != NULL) { |
|
5947
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
883 char locked_message_buf[BUFLEN]; |
|
7961
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
884 found_flag->get_locked_message(locked_message_buf, BUFLEN); |
|
5947
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
885 if (strlen(locked_message_buf) == 0) { |
|
7961
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
886 if (found_flag->is_bool() && !has_plus_minus) { |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
887 jio_fprintf(defaultStream::error_stream(), |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
888 "Missing +/- setting for VM option '%s'\n", argname); |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
889 } else if (!found_flag->is_bool() && has_plus_minus) { |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
890 jio_fprintf(defaultStream::error_stream(), |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
891 "Unexpected +/- setting in VM option '%s'\n", argname); |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
892 } else { |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
893 jio_fprintf(defaultStream::error_stream(), |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
894 "Improperly specified VM option '%s'\n", argname); |
|
baf7fac3167e
8006298: Specifying malformed JFR options (-XX:+FlightRecorderOptions) outputs non-sensical error
hseigel
parents:
7951
diff
changeset
|
895 } |
|
5947
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
896 } else { |
|
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
897 jio_fprintf(defaultStream::error_stream(), "%s", locked_message_buf); |
|
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
898 } |
| 6017 | 899 } else { |
| 900 jio_fprintf(defaultStream::error_stream(), | |
| 901 "Unrecognized VM option '%s'\n", argname); | |
| 11070 | 902 Flag* fuzzy_matched = Flag::fuzzy_match((const char*)argname, arg_len, true); |
| 903 if (fuzzy_matched != NULL) { | |
| 904 jio_fprintf(defaultStream::error_stream(), | |
| 905 "Did you mean '%s%s%s'?\n", | |
| 906 (fuzzy_matched->is_bool()) ? "(+/-)" : "", | |
| 907 fuzzy_matched->name, | |
| 908 (fuzzy_matched->is_bool()) ? "" : "=<value>"); | |
| 909 } | |
|
5947
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
910 } |
|
80fe40862b02
7144328: Improper commandlines for -XX:+-UnlockCommercialFeatures require proper warning/error messages
jmelvin
parents:
5915
diff
changeset
|
911 |
| 3250 | 912 // allow for commandline "commenting out" options like -XX:#+Verbose |
| 913 return arg[0] == '#'; | |
| 0 | 914 } |
| 915 | |
| 916 bool Arguments::process_settings_file(const char* file_name, bool should_exist, jboolean ignore_unrecognized) { | |
| 917 FILE* stream = fopen(file_name, "rb"); | |
| 918 if (stream == NULL) { | |
| 919 if (should_exist) { | |
| 920 jio_fprintf(defaultStream::error_stream(), | |
| 921 "Could not open settings file %s\n", file_name); | |
| 922 return false; | |
| 923 } else { | |
| 924 return true; | |
| 925 } | |
| 926 } | |
| 927 | |
| 928 char token[1024]; | |
| 929 int pos = 0; | |
| 930 | |
| 931 bool in_white_space = true; | |
| 932 bool in_comment = false; | |
| 933 bool in_quote = false; | |
| 934 char quote_c = 0; | |
| 935 bool result = true; | |
| 936 | |
| 937 int c = getc(stream); | |
| 6901 | 938 while(c != EOF && pos < (int)(sizeof(token)-1)) { |
| 0 | 939 if (in_white_space) { |
| 940 if (in_comment) { | |
| 941 if (c == '\n') in_comment = false; | |
| 942 } else { | |
| 943 if (c == '#') in_comment = true; | |
| 944 else if (!isspace(c)) { | |
| 945 in_white_space = false; | |
| 946 token[pos++] = c; | |
| 947 } | |
| 948 } | |
| 949 } else { | |
| 950 if (c == '\n' || (!in_quote && isspace(c))) { | |
| 951 // token ends at newline, or at unquoted whitespace | |
| 952 // this allows a way to include spaces in string-valued options | |
| 953 token[pos] = '\0'; | |
| 954 logOption(token); | |
| 955 result &= process_argument(token, ignore_unrecognized, CONFIG_FILE); | |
| 956 build_jvm_flags(token); | |
| 957 pos = 0; | |
| 958 in_white_space = true; | |
| 959 in_quote = false; | |
| 960 } else if (!in_quote && (c == '\'' || c == '"')) { | |
| 961 in_quote = true; | |
| 962 quote_c = c; | |
| 963 } else if (in_quote && (c == quote_c)) { | |
| 964 in_quote = false; | |
| 965 } else { | |
| 966 token[pos++] = c; | |
| 967 } | |
| 968 } | |
| 969 c = getc(stream); | |
| 970 } | |
| 971 if (pos > 0) { | |
| 972 token[pos] = '\0'; | |
| 973 result &= process_argument(token, ignore_unrecognized, CONFIG_FILE); | |
| 974 build_jvm_flags(token); | |
| 975 } | |
| 976 fclose(stream); | |
| 977 return result; | |
| 978 } | |
| 979 | |
| 980 //============================================================================================================= | |
| 981 // Parsing of properties (-D) | |
| 982 | |
| 983 const char* Arguments::get_property(const char* key) { | |
| 984 return PropertyList_get_value(system_properties(), key); | |
| 985 } | |
| 986 | |
| 987 bool Arguments::add_property(const char* prop) { | |
| 988 const char* eq = strchr(prop, '='); | |
| 989 char* key; | |
| 990 // ns must be static--its address may be stored in a SystemProperty object. | |
| 991 const static char ns[1] = {0}; | |
| 992 char* value = (char *)ns; | |
| 993 | |
| 994 size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop); | |
| 6197 | 995 key = AllocateHeap(key_len + 1, mtInternal); |
| 0 | 996 strncpy(key, prop, key_len); |
| 997 key[key_len] = '\0'; | |
| 998 | |
| 999 if (eq != NULL) { | |
| 1000 size_t value_len = strlen(prop) - key_len - 1; | |
| 6197 | 1001 value = AllocateHeap(value_len + 1, mtInternal); |
| 0 | 1002 strncpy(value, &prop[key_len + 1], value_len + 1); |
| 1003 } | |
| 1004 | |
| 1005 if (strcmp(key, "java.compiler") == 0) { | |
| 1006 process_java_compiler_argument(value); | |
| 1007 FreeHeap(key); | |
| 1008 if (eq != NULL) { | |
| 1009 FreeHeap(value); | |
| 1010 } | |
| 1011 return true; | |
| 691 | 1012 } else if (strcmp(key, "sun.java.command") == 0) { |
| 0 | 1013 _java_command = value; |
| 1014 | |
|
2129
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2095
diff
changeset
|
1015 // Record value in Arguments, but let it get passed to Java. |
| 691 | 1016 } else if (strcmp(key, "sun.java.launcher.pid") == 0) { |
| 0 | 1017 // launcher.pid property is private and is processed |
| 1018 // in process_sun_java_launcher_properties(); | |
| 1019 // the sun.java.launcher property is passed on to the java application | |
| 1020 FreeHeap(key); | |
| 1021 if (eq != NULL) { | |
| 1022 FreeHeap(value); | |
| 1023 } | |
| 1024 return true; | |
| 691 | 1025 } else if (strcmp(key, "java.vendor.url.bug") == 0) { |
| 0 | 1026 // save it in _java_vendor_url_bug, so JVM fatal error handler can access |
| 1027 // its value without going through the property list or making a Java call. | |
| 1028 _java_vendor_url_bug = value; | |
| 691 | 1029 } else if (strcmp(key, "sun.boot.library.path") == 0) { |
| 1030 PropertyList_unique_add(&_system_properties, key, value, true); | |
| 1031 return true; | |
| 0 | 1032 } |
| 1033 // Create new property and add at the end of the list | |
| 1034 PropertyList_unique_add(&_system_properties, key, value); | |
| 1035 return true; | |
| 1036 } | |
| 1037 | |
| 1038 //=========================================================================================================== | |
| 1039 // Setting int/mixed/comp mode flags | |
| 1040 | |
| 1041 void Arguments::set_mode_flags(Mode mode) { | |
| 1042 // Set up default values for all flags. | |
| 1043 // If you add a flag to any of the branches below, | |
| 1044 // add a default value for it here. | |
| 1045 set_java_compiler(false); | |
| 1046 _mode = mode; | |
| 1047 | |
| 1048 // Ensure Agent_OnLoad has the correct initial values. | |
| 1049 // This may not be the final mode; mode may change later in onload phase. | |
| 1050 PropertyList_unique_add(&_system_properties, "java.vm.info", | |
|
3326
6c978a541c03
7036267: c2/arm: mark version number as experimental and disable on unsupported platforms
dholmes
parents:
3261
diff
changeset
|
1051 (char*)VM_Version::vm_info_string(), false); |
| 0 | 1052 |
| 1053 UseInterpreter = true; | |
| 1054 UseCompiler = true; | |
| 1055 UseLoopCounter = true; | |
| 1056 | |
|
2458
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1057 #ifndef ZERO |
|
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1058 // Turn these off for mixed and comp. Leave them on for Zero. |
|
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1059 if (FLAG_IS_DEFAULT(UseFastAccessorMethods)) { |
|
3341
e9b8ef09622a
7041582: set_mode_flags isn't called without -Xmixed specified
never
parents:
3261
diff
changeset
|
1060 UseFastAccessorMethods = (mode == _int); |
|
2458
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1061 } |
|
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1062 if (FLAG_IS_DEFAULT(UseFastEmptyMethods)) { |
|
3341
e9b8ef09622a
7041582: set_mode_flags isn't called without -Xmixed specified
never
parents:
3261
diff
changeset
|
1063 UseFastEmptyMethods = (mode == _int); |
|
2458
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1064 } |
|
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1065 #endif |
|
98c560260039
7034513: enable fast accessors and empty methods for ZERO and -Xint
never
parents:
2416
diff
changeset
|
1066 |
| 0 | 1067 // Default values may be platform/compiler dependent - |
| 1068 // use the saved values | |
| 1069 ClipInlining = Arguments::_ClipInlining; | |
| 1070 AlwaysCompileLoopMethods = Arguments::_AlwaysCompileLoopMethods; | |
| 1071 UseOnStackReplacement = Arguments::_UseOnStackReplacement; | |
| 1072 BackgroundCompilation = Arguments::_BackgroundCompilation; | |
| 1073 | |
| 1074 // Change from defaults based on mode | |
| 1075 switch (mode) { | |
| 1076 default: | |
| 1077 ShouldNotReachHere(); | |
| 1078 break; | |
| 1079 case _int: | |
| 1080 UseCompiler = false; | |
| 1081 UseLoopCounter = false; | |
| 1082 AlwaysCompileLoopMethods = false; | |
| 1083 UseOnStackReplacement = false; | |
| 1084 break; | |
| 1085 case _mixed: | |
| 1086 // same as default | |
| 1087 break; | |
| 1088 case _comp: | |
| 1089 UseInterpreter = false; | |
| 1090 BackgroundCompilation = false; | |
| 1091 ClipInlining = false; | |
|
4758
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1092 // Be much more aggressive in tiered mode with -Xcomp and exercise C2 more. |
|
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1093 // We will first compile a level 3 version (C1 with full profiling), then do one invocation of it and |
|
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1094 // compile a level 4 (C2) and then continue executing it. |
|
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1095 if (TieredCompilation) { |
|
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1096 Tier3InvokeNotifyFreqLog = 0; |
|
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1097 Tier4InvocationThreshold = 0; |
|
d725f0affb1a
7121111: -server -Xcomp -XX:+TieredCompilation does not invoke C2 compiler
iveresov
parents:
4111
diff
changeset
|
1098 } |
| 0 | 1099 break; |
| 1100 } | |
| 1101 } | |
| 1102 | |
| 1103 // Conflict: required to use shared spaces (-Xshare:on), but | |
| 1104 // incompatible command line options were chosen. | |
| 1105 | |
| 1106 static void no_shared_spaces() { | |
| 1107 if (RequireSharedSpaces) { | |
| 1108 jio_fprintf(defaultStream::error_stream(), | |
| 1109 "Class data sharing is inconsistent with other specified options.\n"); | |
| 1110 vm_exit_during_initialization("Unable to use shared archive.", NULL); | |
| 1111 } else { | |
| 1112 FLAG_SET_DEFAULT(UseSharedSpaces, false); | |
| 1113 } | |
| 1114 } | |
| 1115 | |
| 1783 | 1116 void Arguments::set_tiered_flags() { |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2325
diff
changeset
|
1117 // With tiered, set default policy to AdvancedThresholdPolicy, which is 3. |
| 1783 | 1118 if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) { |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
2325
diff
changeset
|
1119 FLAG_SET_DEFAULT(CompilationPolicyChoice, 3); |
| 1783 | 1120 } |
| 1121 if (CompilationPolicyChoice < 2) { | |
| 1122 vm_exit_during_initialization( | |
| 1123 "Incompatible compilation policy selected", NULL); | |
| 1124 } | |
|
1891
9de67bf4244d
6996136: VM crash in src/share/vm/runtime/virtualspace.cpp:424
iveresov
parents:
1890
diff
changeset
|
1125 // Increase the code cache size - tiered compiles a lot more. |
| 1783 | 1126 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) { |
|
8043
309460dcedf7
8006851: When TieredCompilation is set, max code cache should be bumped to 256mb
morris
parents:
8003
diff
changeset
|
1127 FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 5); |
| 1783 | 1128 } |
| 10278 | 1129 if (!UseInterpreter) { // -Xcomp |
| 1130 Tier3InvokeNotifyFreqLog = 0; | |
| 1131 Tier4InvocationThreshold = 0; | |
| 1132 } | |
| 1783 | 1133 } |
| 1134 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
1135 #if INCLUDE_ALL_GCS |
| 4838 | 1136 static void disable_adaptive_size_policy(const char* collector_name) { |
| 1137 if (UseAdaptiveSizePolicy) { | |
| 1138 if (FLAG_IS_CMDLINE(UseAdaptiveSizePolicy)) { | |
| 1139 warning("disabling UseAdaptiveSizePolicy; it is incompatible with %s.", | |
| 1140 collector_name); | |
| 1141 } | |
| 1142 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false); | |
| 1143 } | |
| 1144 } | |
| 1145 | |
| 0 | 1146 void Arguments::set_parnew_gc_flags() { |
| 1064 | 1147 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC, |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1148 "control point invariant"); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1149 assert(UseParNewGC, "Error"); |
| 0 | 1150 |
| 4838 | 1151 // Turn off AdaptiveSizePolicy for parnew until it is complete. |
| 1152 disable_adaptive_size_policy("UseParNewGC"); | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1153 |
|
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1154 if (FLAG_IS_DEFAULT(ParallelGCThreads)) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1155 FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads()); |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1156 assert(ParallelGCThreads > 0, "We should always have at least one thread by default"); |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1157 } else if (ParallelGCThreads == 0) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1158 jio_fprintf(defaultStream::error_stream(), |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1159 "The ParNew GC can not be combined with -XX:ParallelGCThreads=0\n"); |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1160 vm_exit(1); |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1161 } |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1162 |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1163 // By default YoungPLABSize and OldPLABSize are set to 4096 and 1024 respectively, |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1164 // these settings are default for Parallel Scavenger. For ParNew+Tenured configuration |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1165 // we set them to 1024 and 1024. |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1166 // See CR 6362902. |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1167 if (FLAG_IS_DEFAULT(YoungPLABSize)) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1168 FLAG_SET_DEFAULT(YoungPLABSize, (intx)1024); |
| 0 | 1169 } |
|
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1170 if (FLAG_IS_DEFAULT(OldPLABSize)) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1171 FLAG_SET_DEFAULT(OldPLABSize, (intx)1024); |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1172 } |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1173 |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1174 // AlwaysTenure flag should make ParNew promote all at first collection. |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1175 // See CR 6362902. |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1176 if (AlwaysTenure) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1177 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0); |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1178 } |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1179 // When using compressed oops, we use local overflow stacks, |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1180 // rather than using a global overflow list chained through |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1181 // the klass word of the object's pre-image. |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1182 if (UseCompressedOops && !ParGCUseLocalOverflow) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1183 if (!FLAG_IS_DEFAULT(ParGCUseLocalOverflow)) { |
|
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1184 warning("Forcing +ParGCUseLocalOverflow: needed if using compressed references"); |
| 0 | 1185 } |
|
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1186 FLAG_SET_DEFAULT(ParGCUseLocalOverflow, true); |
| 0 | 1187 } |
|
7451
ca0a78017dc7
8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines
brutisso
parents:
7397
diff
changeset
|
1188 assert(ParGCUseLocalOverflow || !UseCompressedOops, "Error"); |
| 0 | 1189 } |
| 1190 | |
| 1191 // Adjust some sizes to suit CMS and/or ParNew needs; these work well on | |
| 1192 // sparc/solaris for certain applications, but would gain from | |
| 1193 // further optimization and tuning efforts, and would almost | |
| 1194 // certainly gain from analysis of platform and environment. | |
| 1195 void Arguments::set_cms_and_parnew_gc_flags() { | |
| 1064 | 1196 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC, "Error"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1197 assert(UseConcMarkSweepGC, "CMS is expected to be on here"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1198 |
| 0 | 1199 // If we are using CMS, we prefer to UseParNewGC, |
| 1200 // unless explicitly forbidden. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1201 if (FLAG_IS_DEFAULT(UseParNewGC)) { |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1202 FLAG_SET_ERGO(bool, UseParNewGC, true); |
| 0 | 1203 } |
| 1204 | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
1205 // Turn off AdaptiveSizePolicy by default for cms until it is complete. |
| 4838 | 1206 disable_adaptive_size_policy("UseConcMarkSweepGC"); |
| 0 | 1207 |
| 1208 // In either case, adjust ParallelGCThreads and/or UseParNewGC | |
| 1209 // as needed. | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1210 if (UseParNewGC) { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1211 set_parnew_gc_flags(); |
| 0 | 1212 } |
| 1213 | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1214 size_t max_heap = align_size_down(MaxHeapSize, |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1215 CardTableRS::ct_max_alignment_constraint()); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1216 |
| 0 | 1217 // Now make adjustments for CMS |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1218 intx tenuring_default = (intx)6; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1219 size_t young_gen_per_worker = CMSYoungGenPerWorker; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1220 |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1221 // Preferred young gen size for "short" pauses: |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1222 // upper bound depends on # of threads and NewRatio. |
| 0 | 1223 const uintx parallel_gc_threads = |
| 1224 (ParallelGCThreads == 0 ? 1 : ParallelGCThreads); | |
| 1225 const size_t preferred_max_new_size_unaligned = | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1226 MIN2(max_heap/(NewRatio+1), ScaleForWordSize(young_gen_per_worker * parallel_gc_threads)); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1227 size_t preferred_max_new_size = |
| 0 | 1228 align_size_up(preferred_max_new_size_unaligned, os::vm_page_size()); |
| 1229 | |
| 1230 // Unless explicitly requested otherwise, size young gen | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1231 // for "short" pauses ~ CMSYoungGenPerWorker*ParallelGCThreads |
|
886
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1232 |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1233 // If either MaxNewSize or NewRatio is set on the command line, |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1234 // assume the user is trying to set the size of the young gen. |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1235 if (FLAG_IS_DEFAULT(MaxNewSize) && FLAG_IS_DEFAULT(NewRatio)) { |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1236 |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1237 // Set MaxNewSize to our calculated preferred_max_new_size unless |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1238 // NewSize was set on the command line and it is larger than |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1239 // preferred_max_new_size. |
| 0 | 1240 if (!FLAG_IS_DEFAULT(NewSize)) { // NewSize explicitly set at command-line |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1241 FLAG_SET_ERGO(uintx, MaxNewSize, MAX2(NewSize, preferred_max_new_size)); |
| 0 | 1242 } else { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1243 FLAG_SET_ERGO(uintx, MaxNewSize, preferred_max_new_size); |
| 0 | 1244 } |
| 1064 | 1245 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1246 // Too early to use gclog_or_tty |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1247 tty->print_cr("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize); |
|
886
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1248 } |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1249 |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1250 // Code along this path potentially sets NewSize and OldSize |
| 1064 | 1251 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1252 // Too early to use gclog_or_tty |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1253 tty->print_cr("CMS set min_heap_size: " SIZE_FORMAT |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1254 " initial_heap_size: " SIZE_FORMAT |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1255 " max_heap: " SIZE_FORMAT, |
| 1064 | 1256 min_heap_size(), InitialHeapSize, max_heap); |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1257 } |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1258 size_t min_new = preferred_max_new_size; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1259 if (FLAG_IS_CMDLINE(NewSize)) { |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1260 min_new = NewSize; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1261 } |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1262 if (max_heap > min_new && min_heap_size() > min_new) { |
| 0 | 1263 // Unless explicitly requested otherwise, make young gen |
| 1264 // at least min_new, and at most preferred_max_new_size. | |
| 1265 if (FLAG_IS_DEFAULT(NewSize)) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1266 FLAG_SET_ERGO(uintx, NewSize, MAX2(NewSize, min_new)); |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1267 FLAG_SET_ERGO(uintx, NewSize, MIN2(preferred_max_new_size, NewSize)); |
| 1064 | 1268 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1269 // Too early to use gclog_or_tty |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1270 tty->print_cr("CMS ergo set NewSize: " SIZE_FORMAT, NewSize); |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1271 } |
| 0 | 1272 } |
| 1273 // Unless explicitly requested otherwise, size old gen | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1274 // so it's NewRatio x of NewSize. |
| 0 | 1275 if (FLAG_IS_DEFAULT(OldSize)) { |
| 1276 if (max_heap > NewSize) { | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1277 FLAG_SET_ERGO(uintx, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize)); |
| 1064 | 1278 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1279 // Too early to use gclog_or_tty |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1280 tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize); |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1281 } |
| 0 | 1282 } |
| 1283 } | |
| 1284 } | |
| 1285 } | |
| 1286 // Unless explicitly requested otherwise, definitely | |
| 1287 // promote all objects surviving "tenuring_default" scavenges. | |
| 1288 if (FLAG_IS_DEFAULT(MaxTenuringThreshold) && | |
| 1289 FLAG_IS_DEFAULT(SurvivorRatio)) { | |
| 6818 | 1290 FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default); |
| 0 | 1291 } |
| 1292 // If we decided above (or user explicitly requested) | |
| 1293 // `promote all' (via MaxTenuringThreshold := 0), | |
| 1294 // prefer minuscule survivor spaces so as not to waste | |
| 1295 // space for (non-existent) survivors | |
| 1296 if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) { | |
| 8035 | 1297 FLAG_SET_ERGO(uintx, SurvivorRatio, MAX2((uintx)1024, SurvivorRatio)); |
| 0 | 1298 } |
| 1299 // If OldPLABSize is set and CMSParPromoteBlocksToClaim is not, | |
| 1300 // set CMSParPromoteBlocksToClaim equal to OldPLABSize. | |
| 1301 // This is done in order to make ParNew+CMS configuration to work | |
| 1302 // with YoungPLABSize and OldPLABSize options. | |
| 1303 // See CR 6362902. | |
| 1304 if (!FLAG_IS_DEFAULT(OldPLABSize)) { | |
| 1305 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1306 // OldPLABSize is not the default value but CMSParPromoteBlocksToClaim |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1307 // is. In this situtation let CMSParPromoteBlocksToClaim follow |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1308 // the value (either from the command line or ergonomics) of |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1309 // OldPLABSize. Following OldPLABSize is an ergonomics decision. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1310 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, OldPLABSize); |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1311 } else { |
| 0 | 1312 // OldPLABSize and CMSParPromoteBlocksToClaim are both set. |
| 1313 // CMSParPromoteBlocksToClaim is a collector-specific flag, so | |
| 1314 // we'll let it to take precedence. | |
| 1315 jio_fprintf(defaultStream::error_stream(), | |
|
886
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1316 "Both OldPLABSize and CMSParPromoteBlocksToClaim" |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1317 " options are specified for the CMS collector." |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1318 " CMSParPromoteBlocksToClaim will take precedence.\n"); |
| 0 | 1319 } |
| 1320 } | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1321 if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1322 // OldPLAB sizing manually turned off: Use a larger default setting, |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1323 // unless it was manually specified. This is because a too-low value |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1324 // will slow down scavenges. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1325 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1326 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, 50); // default value before 6631166 |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1327 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1328 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1329 // Overwrite OldPLABSize which is the variable we will internally use everywhere. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1330 FLAG_SET_ERGO(uintx, OldPLABSize, CMSParPromoteBlocksToClaim); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1331 // If either of the static initialization defaults have changed, note this |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1332 // modification. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1333 if (!FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim) || !FLAG_IS_DEFAULT(OldPLABWeight)) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1334 CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1335 } |
| 1284 | 1336 if (PrintGCDetails && Verbose) { |
| 1337 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", | |
| 1338 MarkStackSize / K, MarkStackSizeMax / K); | |
| 1339 tty->print_cr("ConcGCThreads: %u", ConcGCThreads); | |
| 1340 } | |
| 0 | 1341 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
1342 #endif // INCLUDE_ALL_GCS |
| 0 | 1343 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1344 void set_object_alignment() { |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1345 // Object alignment. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1346 assert(is_power_of_2(ObjectAlignmentInBytes), "ObjectAlignmentInBytes must be power of 2"); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1347 MinObjAlignmentInBytes = ObjectAlignmentInBytes; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1348 assert(MinObjAlignmentInBytes >= HeapWordsPerLong * HeapWordSize, "ObjectAlignmentInBytes value is too small"); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1349 MinObjAlignment = MinObjAlignmentInBytes / HeapWordSize; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1350 assert(MinObjAlignmentInBytes == MinObjAlignment * HeapWordSize, "ObjectAlignmentInBytes value is incorrect"); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1351 MinObjAlignmentInBytesMask = MinObjAlignmentInBytes - 1; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1352 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1353 LogMinObjAlignmentInBytes = exact_log2(ObjectAlignmentInBytes); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1354 LogMinObjAlignment = LogMinObjAlignmentInBytes - LogHeapWordSize; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1355 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1356 // Oop encoding heap max |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1357 OopEncodingHeapMax = (uint64_t(max_juint) + 1) << LogMinObjAlignmentInBytes; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1358 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
1359 #if INCLUDE_ALL_GCS |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1360 // Set CMS global values |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1361 CompactibleFreeListSpace::set_cms_values(); |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
1362 #endif // INCLUDE_ALL_GCS |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1363 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1364 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1365 bool verify_object_alignment() { |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1366 // Object alignment. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1367 if (!is_power_of_2(ObjectAlignmentInBytes)) { |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1368 jio_fprintf(defaultStream::error_stream(), |
|
1829
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1369 "error: ObjectAlignmentInBytes=%d must be power of 2\n", |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1370 (int)ObjectAlignmentInBytes); |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1371 return false; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1372 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1373 if ((int)ObjectAlignmentInBytes < BytesPerLong) { |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1374 jio_fprintf(defaultStream::error_stream(), |
|
1829
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1375 "error: ObjectAlignmentInBytes=%d must be greater or equal %d\n", |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1376 (int)ObjectAlignmentInBytes, BytesPerLong); |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1377 return false; |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1378 } |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1379 // It does not make sense to have big object alignment |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1380 // since a space lost due to alignment will be greater |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1381 // then a saved space from compressed oops. |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1382 if ((int)ObjectAlignmentInBytes > 256) { |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1383 jio_fprintf(defaultStream::error_stream(), |
|
7461
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7458
diff
changeset
|
1384 "error: ObjectAlignmentInBytes=%d must not be greater than 256\n", |
|
1829
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1385 (int)ObjectAlignmentInBytes); |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1386 return false; |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1387 } |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1388 // In case page size is very small. |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1389 if ((int)ObjectAlignmentInBytes >= os::vm_page_size()) { |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1390 jio_fprintf(defaultStream::error_stream(), |
|
7461
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7458
diff
changeset
|
1391 "error: ObjectAlignmentInBytes=%d must be less than page size %d\n", |
|
1829
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1392 (int)ObjectAlignmentInBytes, os::vm_page_size()); |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1393 return false; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1394 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1395 return true; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1396 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1397 |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1398 uintx Arguments::max_heap_for_compressed_oops() { |
| 1963 | 1399 // Avoid sign flip. |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1400 assert(OopEncodingHeapMax > (uint64_t)os::vm_page_size(), "Unusual page size"); |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1401 // We need to fit both the NULL page and the heap into the memory budget, while |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1402 // keeping alignment constraints of the heap. To guarantee the latter, as the |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1403 // NULL page is located before the heap, we pad the NULL page to the conservative |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1404 // maximum alignment that the GC may ever impose upon the heap. |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1405 size_t displacement_due_to_null_page = align_size_up_(os::vm_page_size(), |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1406 Arguments::conservative_max_heap_alignment()); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1407 |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1408 LP64_ONLY(return OopEncodingHeapMax - displacement_due_to_null_page); |
| 1064 | 1409 NOT_LP64(ShouldNotReachHere(); return 0); |
|
135
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
113
diff
changeset
|
1410 } |
|
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
113
diff
changeset
|
1411 |
| 0 | 1412 bool Arguments::should_auto_select_low_pause_collector() { |
| 1413 if (UseAutoGCSelectPolicy && | |
| 1414 !FLAG_IS_DEFAULT(MaxGCPauseMillis) && | |
| 1415 (MaxGCPauseMillis <= AutoGCSelectPauseMillis)) { | |
| 1416 if (PrintGCDetails) { | |
| 1417 // Cannot use gclog_or_tty yet. | |
| 1418 tty->print_cr("Automatic selection of the low pause collector" | |
| 1419 " based on pause goal of %d (ms)", MaxGCPauseMillis); | |
| 1420 } | |
| 1421 return true; | |
| 1422 } | |
| 1423 return false; | |
| 1424 } | |
| 1425 | |
|
8741
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1426 void Arguments::set_use_compressed_oops() { |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1427 #ifndef ZERO |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1428 #ifdef _LP64 |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1429 // MaxHeapSize is not set up properly at this point, but |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1430 // the only value that can override MaxHeapSize if we are |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1431 // to use UseCompressedOops is InitialHeapSize. |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1432 size_t max_heap_size = MAX2(MaxHeapSize, InitialHeapSize); |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1433 |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1434 if (max_heap_size <= max_heap_for_compressed_oops()) { |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1435 #if !defined(COMPILER1) || defined(TIERED) |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1436 if (FLAG_IS_DEFAULT(UseCompressedOops)) { |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1437 FLAG_SET_ERGO(bool, UseCompressedOops, true); |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1438 } |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1439 #endif |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1440 #ifdef _WIN64 |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1441 if (UseLargePages && UseCompressedOops) { |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1442 // Cannot allocate guard pages for implicit checks in indexed addressing |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1443 // mode, when large pages are specified on windows. |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1444 // This flag could be switched ON if narrow oop base address is set to 0, |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1445 // see code in Universe::initialize_heap(). |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1446 Universe::set_narrow_oop_use_implicit_null_checks(false); |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1447 } |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1448 #endif // _WIN64 |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1449 } else { |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1450 if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) { |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1451 warning("Max heap size too large for Compressed Oops"); |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1452 FLAG_SET_DEFAULT(UseCompressedOops, false); |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1453 FLAG_SET_DEFAULT(UseCompressedClassPointers, false); |
|
8741
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1454 } |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1455 } |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1456 #endif // _LP64 |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1457 #endif // ZERO |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1458 } |
|
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1459 |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1460 |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1461 // NOTE: set_use_compressed_klass_ptrs() must be called after calling |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1462 // set_use_compressed_oops(). |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1463 void Arguments::set_use_compressed_klass_ptrs() { |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1464 #ifndef ZERO |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1465 #ifdef _LP64 |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1466 // UseCompressedOops must be on for UseCompressedClassPointers to be on. |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1467 if (!UseCompressedOops) { |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1468 if (UseCompressedClassPointers) { |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1469 warning("UseCompressedClassPointers requires UseCompressedOops"); |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1470 } |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1471 FLAG_SET_DEFAULT(UseCompressedClassPointers, false); |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1472 } else { |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1473 // Turn on UseCompressedClassPointers too |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1474 if (FLAG_IS_DEFAULT(UseCompressedClassPointers)) { |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1475 FLAG_SET_ERGO(bool, UseCompressedClassPointers, true); |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1476 } |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1477 // Check the CompressedClassSpaceSize to make sure we use compressed klass ptrs. |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1478 if (UseCompressedClassPointers) { |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1479 if (CompressedClassSpaceSize > KlassEncodingMetaspaceMax) { |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1480 warning("CompressedClassSpaceSize is too large for UseCompressedClassPointers"); |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
1481 FLAG_SET_DEFAULT(UseCompressedClassPointers, false); |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1482 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1483 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1484 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1485 #endif // _LP64 |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1486 #endif // !ZERO |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1487 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1488 |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1489 void Arguments::set_conservative_max_heap_alignment() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1490 // The conservative maximum required alignment for the heap is the maximum of |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1491 // the alignments imposed by several sources: any requirements from the heap |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1492 // itself, the collector policy and the maximum page size we may run the VM |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1493 // with. |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1494 size_t heap_alignment = GenCollectedHeap::conservative_max_heap_alignment(); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1495 #if INCLUDE_ALL_GCS |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1496 if (UseParallelGC) { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1497 heap_alignment = ParallelScavengeHeap::conservative_max_heap_alignment(); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1498 } else if (UseG1GC) { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1499 heap_alignment = G1CollectedHeap::conservative_max_heap_alignment(); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1500 } |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1501 #endif // INCLUDE_ALL_GCS |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1502 _conservative_max_heap_alignment = MAX3(heap_alignment, os::max_page_size(), |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1503 CollectorPolicy::compute_max_alignment()); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1504 } |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1505 |
| 0 | 1506 void Arguments::set_ergonomics_flags() { |
| 1507 | |
| 4946 | 1508 if (os::is_server_class_machine()) { |
| 0 | 1509 // If no other collector is requested explicitly, |
| 1510 // let the VM select the collector based on | |
| 1511 // machine class and automatic selection policy. | |
| 1512 if (!UseSerialGC && | |
| 1513 !UseConcMarkSweepGC && | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1514 !UseG1GC && |
| 0 | 1515 !UseParNewGC && |
| 1516 FLAG_IS_DEFAULT(UseParallelGC)) { | |
| 1517 if (should_auto_select_low_pause_collector()) { | |
| 1518 FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true); | |
| 1519 } else { | |
| 1520 FLAG_SET_ERGO(bool, UseParallelGC, true); | |
| 1521 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
1522 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
1523 // Shared spaces work fine with other GCs but causes bytecode rewriting |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
1524 // to be disabled, which hurts interpreter performance and decreases |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
1525 // server performance. On server class machines, keep the default |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
1526 // off unless it is asked for. Future work: either add bytecode rewriting |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
1527 // at link time, or rewrite bytecodes in non-shared methods. |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1528 if (!DumpSharedSpaces && !RequireSharedSpaces && |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1529 (FLAG_IS_DEFAULT(UseSharedSpaces) || !UseSharedSpaces)) { |
| 0 | 1530 no_shared_spaces(); |
| 1531 } | |
| 1532 } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1533 |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1534 set_conservative_max_heap_alignment(); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
1535 |
| 1010 | 1536 #ifndef ZERO |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1537 #ifdef _LP64 |
|
8741
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8734
diff
changeset
|
1538 set_use_compressed_oops(); |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1539 |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1540 // set_use_compressed_klass_ptrs() must be called after calling |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1541 // set_use_compressed_oops(). |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1542 set_use_compressed_klass_ptrs(); |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
1543 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1544 // Also checks that certain machines are slower with compressed oops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1545 // in vm_version initialization code. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1546 #endif // _LP64 |
| 1010 | 1547 #endif // !ZERO |
| 0 | 1548 } |
| 1549 | |
| 1550 void Arguments::set_parallel_gc_flags() { | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1551 assert(UseParallelGC || UseParallelOldGC, "Error"); |
| 4879 | 1552 // Enable ParallelOld unless it was explicitly disabled (cmd line or rc file). |
| 1553 if (FLAG_IS_DEFAULT(UseParallelOldGC)) { | |
| 1554 FLAG_SET_DEFAULT(UseParallelOldGC, true); | |
| 0 | 1555 } |
| 4879 | 1556 FLAG_SET_DEFAULT(UseParallelGC, true); |
| 0 | 1557 |
| 1558 // If no heap maximum was requested explicitly, use some reasonable fraction | |
| 1559 // of the physical memory, up to a maximum of 1GB. | |
|
7471
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1560 FLAG_SET_DEFAULT(ParallelGCThreads, |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1561 Abstract_VM_Version::parallel_worker_threads()); |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1562 if (ParallelGCThreads == 0) { |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1563 jio_fprintf(defaultStream::error_stream(), |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1564 "The Parallel GC can not be combined with -XX:ParallelGCThreads=0\n"); |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1565 vm_exit(1); |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1566 } |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1567 |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1568 |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1569 // If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1570 // SurvivorRatio has been set, reset their default values to SurvivorRatio + |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1571 // 2. By doing this we make SurvivorRatio also work for Parallel Scavenger. |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1572 // See CR 6362902 for details. |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1573 if (!FLAG_IS_DEFAULT(SurvivorRatio)) { |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1574 if (FLAG_IS_DEFAULT(InitialSurvivorRatio)) { |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1575 FLAG_SET_DEFAULT(InitialSurvivorRatio, SurvivorRatio + 2); |
| 0 | 1576 } |
|
7471
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1577 if (FLAG_IS_DEFAULT(MinSurvivorRatio)) { |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1578 FLAG_SET_DEFAULT(MinSurvivorRatio, SurvivorRatio + 2); |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1579 } |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1580 } |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1581 |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1582 if (UseParallelOldGC) { |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1583 // Par compact uses lower default values since they are treated as |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1584 // minimums. These are different defaults because of the different |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1585 // interpretation and are not ergonomically set. |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1586 if (FLAG_IS_DEFAULT(MarkSweepDeadRatio)) { |
|
4c8bf5e55392
8005489: VM hangs during GC with ParallelGC and ParallelGCThreads=0
brutisso
parents:
7453
diff
changeset
|
1587 FLAG_SET_DEFAULT(MarkSweepDeadRatio, 1); |
| 0 | 1588 } |
| 1589 } | |
| 1590 } | |
| 1591 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1592 void Arguments::set_g1_gc_flags() { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1593 assert(UseG1GC, "Error"); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1594 #ifdef COMPILER1 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1595 FastTLABRefill = false; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1596 #endif |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1597 FLAG_SET_DEFAULT(ParallelGCThreads, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1598 Abstract_VM_Version::parallel_worker_threads()); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1599 if (ParallelGCThreads == 0) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1600 FLAG_SET_DEFAULT(ParallelGCThreads, |
| 751 | 1601 Abstract_VM_Version::parallel_worker_threads()); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1602 } |
| 751 | 1603 |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1604 // MarkStackSize will be set (if it hasn't been set by the user) |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1605 // when concurrent marking is initialized. |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1606 // Its value will be based upon the number of parallel marking threads. |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1607 // But we do set the maximum mark stack size here. |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1608 if (FLAG_IS_DEFAULT(MarkStackSizeMax)) { |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1609 FLAG_SET_DEFAULT(MarkStackSizeMax, 128 * TASKQUEUE_SIZE); |
| 1284 | 1610 } |
| 1356 | 1611 |
| 1612 if (FLAG_IS_DEFAULT(GCTimeRatio) || GCTimeRatio == 0) { | |
| 1613 // In G1, we want the default GC overhead goal to be higher than | |
| 1614 // say in PS. So we set it here to 10%. Otherwise the heap might | |
| 1615 // be expanded more aggressively than we would like it to. In | |
| 1616 // fact, even 10% seems to not be high enough in some cases | |
| 1617 // (especially small GC stress tests that the main thing they do | |
| 1618 // is allocation). We might consider increase it further. | |
| 1619 FLAG_SET_DEFAULT(GCTimeRatio, 9); | |
| 1620 } | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1621 |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1622 if (PrintGCDetails && Verbose) { |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1623 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1624 MarkStackSize / K, MarkStackSizeMax / K); |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1625 tty->print_cr("ConcGCThreads: %u", ConcGCThreads); |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
1626 } |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1627 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1628 |
|
8854
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1629 julong Arguments::limit_by_allocatable_memory(julong limit) { |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1630 julong max_allocatable; |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1631 julong result = limit; |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1632 if (os::has_allocatable_memory_limit(&max_allocatable)) { |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1633 result = MIN2(result, max_allocatable / MaxVirtMemFraction); |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1634 } |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1635 return result; |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1636 } |
|
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1637 |
| 1064 | 1638 void Arguments::set_heap_size() { |
| 1639 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) { | |
| 1640 // Deprecated flag | |
| 1641 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction); | |
| 1642 } | |
| 1643 | |
| 1644 const julong phys_mem = | |
| 1645 FLAG_IS_DEFAULT(MaxRAM) ? MIN2(os::physical_memory(), (julong)MaxRAM) | |
| 1646 : (julong)MaxRAM; | |
| 1647 | |
| 1648 // If the maximum heap size has not been set with -Xmx, | |
| 1649 // then set it as fraction of the size of physical memory, | |
| 1650 // respecting the maximum and minimum sizes of the heap. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1651 if (FLAG_IS_DEFAULT(MaxHeapSize)) { |
| 1064 | 1652 julong reasonable_max = phys_mem / MaxRAMFraction; |
| 1653 | |
| 1654 if (phys_mem <= MaxHeapSize * MinRAMFraction) { | |
| 1655 // Small physical memory, so use a minimum fraction of it for the heap | |
| 1656 reasonable_max = phys_mem / MinRAMFraction; | |
| 1657 } else { | |
| 1658 // Not-small physical memory, so require a heap at least | |
| 1659 // as large as MaxHeapSize | |
| 1660 reasonable_max = MAX2(reasonable_max, (julong)MaxHeapSize); | |
| 1661 } | |
| 1662 if (!FLAG_IS_DEFAULT(ErgoHeapSizeLimit) && ErgoHeapSizeLimit != 0) { | |
| 1663 // Limit the heap size to ErgoHeapSizeLimit | |
| 1664 reasonable_max = MIN2(reasonable_max, (julong)ErgoHeapSizeLimit); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1665 } |
| 1064 | 1666 if (UseCompressedOops) { |
| 1667 // Limit the heap size to the maximum possible when using compressed oops | |
| 1963 | 1668 julong max_coop_heap = (julong)max_heap_for_compressed_oops(); |
| 1669 if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) { | |
| 1670 // Heap should be above HeapBaseMinAddress to get zero based compressed oops | |
| 1671 // but it should be not less than default MaxHeapSize. | |
| 1672 max_coop_heap -= HeapBaseMinAddress; | |
| 1673 } | |
| 1674 reasonable_max = MIN2(reasonable_max, max_coop_heap); | |
| 1064 | 1675 } |
|
8854
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1676 reasonable_max = limit_by_allocatable_memory(reasonable_max); |
| 1064 | 1677 |
| 1678 if (!FLAG_IS_DEFAULT(InitialHeapSize)) { | |
| 1679 // An initial heap size was specified on the command line, | |
| 1680 // so be sure that the maximum size is consistent. Done | |
|
8854
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1681 // after call to limit_by_allocatable_memory because that |
| 1064 | 1682 // method might reduce the allocation size. |
| 1683 reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize); | |
| 1684 } | |
| 1685 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1686 if (PrintGCDetails && Verbose) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1687 // Cannot use gclog_or_tty yet. |
| 1064 | 1688 tty->print_cr(" Maximum heap size " SIZE_FORMAT, reasonable_max); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1689 } |
| 1064 | 1690 FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx)reasonable_max); |
| 1691 } | |
| 1692 | |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1693 // If the minimum or initial heap_size have not been set or requested to be set |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1694 // ergonomically, set them accordingly. |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1695 if (InitialHeapSize == 0 || min_heap_size() == 0) { |
|
1074
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1696 julong reasonable_minimum = (julong)(OldSize + NewSize); |
|
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1697 |
|
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1698 reasonable_minimum = MIN2(reasonable_minimum, (julong)MaxHeapSize); |
|
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1699 |
|
8854
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
1700 reasonable_minimum = limit_by_allocatable_memory(reasonable_minimum); |
|
1074
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1701 |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1702 if (InitialHeapSize == 0) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1703 julong reasonable_initial = phys_mem / InitialRAMFraction; |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1704 |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1705 reasonable_initial = MAX3(reasonable_initial, reasonable_minimum, (julong)min_heap_size()); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1706 reasonable_initial = MIN2(reasonable_initial, (julong)MaxHeapSize); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1707 |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1708 reasonable_initial = limit_by_allocatable_memory(reasonable_initial); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1709 |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1710 if (PrintGCDetails && Verbose) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1711 // Cannot use gclog_or_tty yet. |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1712 tty->print_cr(" Initial heap size " SIZE_FORMAT, (uintx)reasonable_initial); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1713 } |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1714 FLAG_SET_ERGO(uintx, InitialHeapSize, (uintx)reasonable_initial); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1715 } |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1716 // If the minimum heap size has not been set (via -Xms), |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1717 // synchronize with InitialHeapSize to avoid errors with the default value. |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1718 if (min_heap_size() == 0) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1719 set_min_heap_size(MIN2((uintx)reasonable_minimum, InitialHeapSize)); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1720 if (PrintGCDetails && Verbose) { |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1721 // Cannot use gclog_or_tty yet. |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1722 tty->print_cr(" Minimum heap size " SIZE_FORMAT, min_heap_size()); |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1723 } |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
1724 } |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1725 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1726 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1727 |
| 0 | 1728 // This must be called after ergonomics because we want bytecode rewriting |
| 1729 // if the server compiler is used, or if UseSharedSpaces is disabled. | |
| 1730 void Arguments::set_bytecode_flags() { | |
| 1731 // Better not attempt to store into a read-only space. | |
| 1732 if (UseSharedSpaces) { | |
| 1733 FLAG_SET_DEFAULT(RewriteBytecodes, false); | |
| 1734 FLAG_SET_DEFAULT(RewriteFrequentPairs, false); | |
| 1735 } | |
| 1736 | |
| 1737 if (!RewriteBytecodes) { | |
| 1738 FLAG_SET_DEFAULT(RewriteFrequentPairs, false); | |
| 1739 } | |
| 1740 } | |
| 1741 | |
| 1742 // Aggressive optimization flags -XX:+AggressiveOpts | |
| 1743 void Arguments::set_aggressive_opts_flags() { | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1744 #ifdef COMPILER2 |
| 10278 | 1745 if (AggressiveUnboxing) { |
| 1746 if (FLAG_IS_DEFAULT(EliminateAutoBox)) { | |
| 1747 FLAG_SET_DEFAULT(EliminateAutoBox, true); | |
| 1748 } else if (!EliminateAutoBox) { | |
| 1749 // warning("AggressiveUnboxing is disabled because EliminateAutoBox is disabled"); | |
| 1750 AggressiveUnboxing = false; | |
| 1751 } | |
| 1752 if (FLAG_IS_DEFAULT(DoEscapeAnalysis)) { | |
| 1753 FLAG_SET_DEFAULT(DoEscapeAnalysis, true); | |
| 1754 } else if (!DoEscapeAnalysis) { | |
| 1755 // warning("AggressiveUnboxing is disabled because DoEscapeAnalysis is disabled"); | |
| 1756 AggressiveUnboxing = false; | |
| 1757 } | |
| 1758 } | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1759 if (AggressiveOpts || !FLAG_IS_DEFAULT(AutoBoxCacheMax)) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1760 if (FLAG_IS_DEFAULT(EliminateAutoBox)) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1761 FLAG_SET_DEFAULT(EliminateAutoBox, true); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1762 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1763 if (FLAG_IS_DEFAULT(AutoBoxCacheMax)) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1764 FLAG_SET_DEFAULT(AutoBoxCacheMax, 20000); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1765 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1766 |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1767 // Feed the cache size setting into the JDK |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1768 char buffer[1024]; |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
489
diff
changeset
|
1769 sprintf(buffer, "java.lang.Integer.IntegerCache.high=" INTX_FORMAT, AutoBoxCacheMax); |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1770 add_property(buffer); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1771 } |
|
416
b6cfd754403d
6649622: HotSpot Biased locking needs tuning on latest CPUs
never
parents:
363
diff
changeset
|
1772 if (AggressiveOpts && FLAG_IS_DEFAULT(BiasedLockingStartupDelay)) { |
|
b6cfd754403d
6649622: HotSpot Biased locking needs tuning on latest CPUs
never
parents:
363
diff
changeset
|
1773 FLAG_SET_DEFAULT(BiasedLockingStartupDelay, 500); |
|
b6cfd754403d
6649622: HotSpot Biased locking needs tuning on latest CPUs
never
parents:
363
diff
changeset
|
1774 } |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1775 #endif |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1776 |
| 0 | 1777 if (AggressiveOpts) { |
| 61 | 1778 // Sample flag setting code |
| 1779 // if (FLAG_IS_DEFAULT(EliminateZeroing)) { | |
| 1780 // FLAG_SET_DEFAULT(EliminateZeroing, true); | |
| 1781 // } | |
| 0 | 1782 } |
| 1783 } | |
| 1784 | |
| 1785 //=========================================================================================================== | |
| 1786 // Parsing of java.compiler property | |
| 1787 | |
| 1788 void Arguments::process_java_compiler_argument(char* arg) { | |
| 1789 // For backwards compatibility, Djava.compiler=NONE or "" | |
| 1790 // causes us to switch to -Xint mode UNLESS -Xdebug | |
| 1791 // is also specified. | |
| 1792 if (strlen(arg) == 0 || strcasecmp(arg, "NONE") == 0) { | |
| 1793 set_java_compiler(true); // "-Djava.compiler[=...]" most recently seen. | |
| 1794 } | |
| 1795 } | |
| 1796 | |
| 1797 void Arguments::process_java_launcher_argument(const char* launcher, void* extra_info) { | |
| 1798 _sun_java_launcher = strdup(launcher); | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1799 if (strcmp("gamma", _sun_java_launcher) == 0) { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1800 _created_by_gamma_launcher = true; |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1801 } |
| 0 | 1802 } |
| 1803 | |
| 1804 bool Arguments::created_by_java_launcher() { | |
| 1805 assert(_sun_java_launcher != NULL, "property must have value"); | |
| 1806 return strcmp(DEFAULT_JAVA_LAUNCHER, _sun_java_launcher) != 0; | |
| 1807 } | |
| 1808 | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1809 bool Arguments::created_by_gamma_launcher() { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1810 return _created_by_gamma_launcher; |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1811 } |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1812 |
| 0 | 1813 //=========================================================================================================== |
| 1814 // Parsing of main arguments | |
| 1815 | |
|
1244
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1816 bool Arguments::verify_interval(uintx val, uintx min, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1817 uintx max, const char* name) { |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1818 // Returns true iff value is in the inclusive interval [min..max] |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1819 // false, otherwise. |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1820 if (val >= min && val <= max) { |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1821 return true; |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1822 } |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1823 jio_fprintf(defaultStream::error_stream(), |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1824 "%s of " UINTX_FORMAT " is invalid; must be between " UINTX_FORMAT |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1825 " and " UINTX_FORMAT "\n", |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1826 name, val, min, max); |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1827 return false; |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1828 } |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1829 |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1830 bool Arguments::verify_min_value(intx val, intx min, const char* name) { |
|
2366
1fb790245268
6820066: Check that -XX:ParGCArrayScanChunk has a value larger than zero.
jwilhelm
parents:
2362
diff
changeset
|
1831 // Returns true if given value is at least specified min threshold |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1832 // false, otherwise. |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1833 if (val >= min ) { |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1834 return true; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1835 } |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1836 jio_fprintf(defaultStream::error_stream(), |
|
2366
1fb790245268
6820066: Check that -XX:ParGCArrayScanChunk has a value larger than zero.
jwilhelm
parents:
2362
diff
changeset
|
1837 "%s of " INTX_FORMAT " is invalid; must be at least " INTX_FORMAT "\n", |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1838 name, val, min); |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1839 return false; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1840 } |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1841 |
| 0 | 1842 bool Arguments::verify_percentage(uintx value, const char* name) { |
| 1843 if (value <= 100) { | |
| 1844 return true; | |
| 1845 } | |
| 1846 jio_fprintf(defaultStream::error_stream(), | |
| 1847 "%s of " UINTX_FORMAT " is invalid; must be between 0 and 100\n", | |
| 1848 name, value); | |
| 1849 return false; | |
| 1850 } | |
| 1851 | |
|
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8847
diff
changeset
|
1852 #if !INCLUDE_ALL_GCS |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8847
diff
changeset
|
1853 #ifdef ASSERT |
| 0 | 1854 static bool verify_serial_gc_flags() { |
| 1855 return (UseSerialGC && | |
|
945
68ef3fdcdb76
6872136: CMS: confusing message may be printed when a collector is switched off implicitly
ysr
parents:
932
diff
changeset
|
1856 !(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC || |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1857 UseParallelGC || UseParallelOldGC)); |
| 0 | 1858 } |
|
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8847
diff
changeset
|
1859 #endif // ASSERT |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8847
diff
changeset
|
1860 #endif // INCLUDE_ALL_GCS |
| 0 | 1861 |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1862 // check if do gclog rotation |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1863 // +UseGCLogFileRotation is a must, |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1864 // no gc log rotation when log file not supplied or |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1865 // NumberOfGCLogFiles is 0, or GCLogFileSize is 0 |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1866 void check_gclog_consistency() { |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1867 if (UseGCLogFileRotation) { |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1868 if ((Arguments::gc_log_filename() == NULL) || |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1869 (NumberOfGCLogFiles == 0) || |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1870 (GCLogFileSize == 0)) { |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1871 jio_fprintf(defaultStream::output_stream(), |
|
3769
ef2d1b8f2dd4
7051430: CMS: ongoing CMS cycle should terminate abruptly to allow prompt JVM termination at exit
ysr
parents:
3767
diff
changeset
|
1872 "To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>\n" |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1873 "where num_of_file > 0 and num_of_size > 0\n" |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1874 "GC log rotation is turned off\n"); |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1875 UseGCLogFileRotation = false; |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1876 } |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1877 } |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1878 |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1879 if (UseGCLogFileRotation && GCLogFileSize < 8*K) { |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1880 FLAG_SET_CMDLINE(uintx, GCLogFileSize, 8*K); |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1881 jio_fprintf(defaultStream::output_stream(), |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1882 "GCLogFileSize changed to minimum 8K\n"); |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1883 } |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1884 } |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1885 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1886 // Check consistency of GC selection |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1887 bool Arguments::check_gc_consistency() { |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
1888 check_gclog_consistency(); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1889 bool status = true; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1890 // Ensure that the user has not selected conflicting sets |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1891 // of collectors. [Note: this check is merely a user convenience; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1892 // collectors over-ride each other so that only a non-conflicting |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1893 // set is selected; however what the user gets is not what they |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1894 // may have expected from the combination they asked for. It's |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1895 // better to reduce user confusion by not allowing them to |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1896 // select conflicting combinations. |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1897 uint i = 0; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1898 if (UseSerialGC) i++; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1899 if (UseConcMarkSweepGC || UseParNewGC) i++; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1900 if (UseParallelGC || UseParallelOldGC) i++; |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
751
diff
changeset
|
1901 if (UseG1GC) i++; |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1902 if (i > 1) { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1903 jio_fprintf(defaultStream::error_stream(), |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1904 "Conflicting collector combinations in option list; " |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1905 "please refer to the release notes for the combinations " |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1906 "allowed\n"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1907 status = false; |
|
11109
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
1908 } else if (ReservedCodeCacheSize > 2*G) { |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
1909 // Code cache size larger than MAXINT is not supported. |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
1910 jio_fprintf(defaultStream::error_stream(), |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
1911 "Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M, |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
1912 (2*G)/M); |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
1913 status = false; |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1914 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1915 return status; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1916 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1917 |
|
7452
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1918 void Arguments::check_deprecated_gcs() { |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1919 if (UseConcMarkSweepGC && !UseParNewGC) { |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1920 warning("Using the DefNew young collector with the CMS collector is deprecated " |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1921 "and will likely be removed in a future release"); |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1922 } |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1923 |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1924 if (UseParNewGC && !UseConcMarkSweepGC) { |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1925 // !UseConcMarkSweepGC means that we are using serial old gc. Unfortunately we don't |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1926 // set up UseSerialGC properly, so that can't be used in the check here. |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1927 warning("Using the ParNew young collector with the Serial old collector is deprecated " |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1928 "and will likely be removed in a future release"); |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1929 } |
| 7453 | 1930 |
| 1931 if (CMSIncrementalMode) { | |
| 1932 warning("Using incremental CMS is deprecated and will likely be removed in a future release"); | |
| 1933 } | |
|
7452
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1934 } |
|
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
1935 |
| 8734 | 1936 void Arguments::check_deprecated_gc_flags() { |
| 1937 if (FLAG_IS_CMDLINE(MaxGCMinorPauseMillis)) { | |
| 1938 warning("Using MaxGCMinorPauseMillis as minor pause goal is deprecated" | |
| 1939 "and will likely be removed in future release"); | |
| 1940 } | |
| 11977 | 1941 if (FLAG_IS_CMDLINE(DefaultMaxRAMFraction)) { |
| 1942 warning("DefaultMaxRAMFraction is deprecated and will likely be removed in a future release. " | |
| 1943 "Use MaxRAMFraction instead."); | |
| 1944 } | |
| 8734 | 1945 } |
| 1946 | |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1947 // Check stack pages settings |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1948 bool Arguments::check_stack_pages() |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1949 { |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1950 bool status = true; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1951 status = status && verify_min_value(StackYellowPages, 1, "StackYellowPages"); |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1952 status = status && verify_min_value(StackRedPages, 1, "StackRedPages"); |
|
1867
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1864
diff
changeset
|
1953 // greater stack shadow pages can't generate instruction to bang stack |
|
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1864
diff
changeset
|
1954 status = status && verify_interval(StackShadowPages, 1, 50, "StackShadowPages"); |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1955 return status; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1956 } |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1957 |
| 0 | 1958 // Check the consistency of vm_init_args |
| 1959 bool Arguments::check_vm_args_consistency() { | |
| 1960 // Method for adding checks for flag consistency. | |
| 1961 // The intent is to warn the user of all possible conflicts, | |
| 1962 // before returning an error. | |
| 1963 // Note: Needs platform-dependent factoring. | |
| 1964 bool status = true; | |
| 1965 | |
| 1966 // Allow both -XX:-UseStackBanging and -XX:-UseBoundThreads in non-product | |
| 1967 // builds so the cost of stack banging can be measured. | |
| 1968 #if (defined(PRODUCT) && defined(SOLARIS)) | |
| 1969 if (!UseBoundThreads && !UseStackBanging) { | |
| 1970 jio_fprintf(defaultStream::error_stream(), | |
| 1971 "-UseStackBanging conflicts with -UseBoundThreads\n"); | |
| 1972 | |
| 1973 status = false; | |
| 1974 } | |
| 1975 #endif | |
| 1976 | |
| 1977 if (TLABRefillWasteFraction == 0) { | |
| 1978 jio_fprintf(defaultStream::error_stream(), | |
| 1979 "TLABRefillWasteFraction should be a denominator, " | |
| 1980 "not " SIZE_FORMAT "\n", | |
| 1981 TLABRefillWasteFraction); | |
| 1982 status = false; | |
| 1983 } | |
| 1984 | |
|
10287
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
1985 status = status && verify_interval(AdaptiveSizePolicyWeight, 0, 100, |
| 0 | 1986 "AdaptiveSizePolicyWeight"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1987 status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1988 status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1989 status = status && verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio"); |
| 0 | 1990 |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6928
diff
changeset
|
1991 // Divide by bucket size to prevent a large size from causing rollover when |
|
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6928
diff
changeset
|
1992 // calculating amount of memory needed to be allocated for the String table. |
|
10126
63e31ce40bdb
8009928: PSR:PERF Increase default string table size
hseigel
parents:
9077
diff
changeset
|
1993 status = status && verify_interval(StringTableSize, minimumStringTableSize, |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6928
diff
changeset
|
1994 (max_uintx / StringTable::bucket_size()), "StringTable size"); |
|
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6928
diff
changeset
|
1995 |
| 0 | 1996 if (MinHeapFreeRatio > MaxHeapFreeRatio) { |
| 1997 jio_fprintf(defaultStream::error_stream(), | |
| 1998 "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or " | |
| 1999 "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n", | |
| 2000 MinHeapFreeRatio, MaxHeapFreeRatio); | |
| 2001 status = false; | |
| 2002 } | |
| 2003 // Keeping the heap 100% free is hard ;-) so limit it to 99%. | |
| 2004 MinHeapFreeRatio = MIN2(MinHeapFreeRatio, (uintx) 99); | |
| 2005 | |
|
8040
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2006 // Min/MaxMetaspaceFreeRatio |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2007 status = status && verify_percentage(MinMetaspaceFreeRatio, "MinMetaspaceFreeRatio"); |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2008 status = status && verify_percentage(MaxMetaspaceFreeRatio, "MaxMetaspaceFreeRatio"); |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2009 |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2010 if (MinMetaspaceFreeRatio > MaxMetaspaceFreeRatio) { |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2011 jio_fprintf(defaultStream::error_stream(), |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2012 "MinMetaspaceFreeRatio (%s" UINTX_FORMAT ") must be less than or " |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2013 "equal to MaxMetaspaceFreeRatio (%s" UINTX_FORMAT ")\n", |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2014 FLAG_IS_DEFAULT(MinMetaspaceFreeRatio) ? "Default: " : "", |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2015 MinMetaspaceFreeRatio, |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2016 FLAG_IS_DEFAULT(MaxMetaspaceFreeRatio) ? "Default: " : "", |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2017 MaxMetaspaceFreeRatio); |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2018 status = false; |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2019 } |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2020 |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2021 // Trying to keep 100% free is not practical |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2022 MinMetaspaceFreeRatio = MIN2(MinMetaspaceFreeRatio, (uintx) 99); |
|
a83cd101fd62
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
8037
diff
changeset
|
2023 |
| 0 | 2024 if (FullGCALot && FLAG_IS_DEFAULT(MarkSweepAlwaysCompactCount)) { |
| 2025 MarkSweepAlwaysCompactCount = 1; // Move objects every gc. | |
| 2026 } | |
| 2027 | |
|
483
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2028 if (UseParallelOldGC && ParallelOldGCSplitALot) { |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2029 // Settings to encourage splitting. |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2030 if (!FLAG_IS_CMDLINE(NewRatio)) { |
| 8035 | 2031 FLAG_SET_CMDLINE(uintx, NewRatio, 2); |
|
483
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2032 } |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2033 if (!FLAG_IS_CMDLINE(ScavengeBeforeFullGC)) { |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2034 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2035 } |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2036 } |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
2037 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2038 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2039 status = status && verify_percentage(GCTimeLimit, "GCTimeLimit"); |
| 0 | 2040 if (GCTimeLimit == 100) { |
| 2041 // Turn off gc-overhead-limit-exceeded checks | |
| 2042 FLAG_SET_DEFAULT(UseGCOverheadLimit, false); | |
| 2043 } | |
| 2044 | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2045 status = status && check_gc_consistency(); |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
2046 status = status && check_stack_pages(); |
| 0 | 2047 |
| 2048 if (CMSIncrementalMode) { | |
| 2049 if (!UseConcMarkSweepGC) { | |
| 2050 jio_fprintf(defaultStream::error_stream(), | |
| 2051 "error: invalid argument combination.\n" | |
| 2052 "The CMS collector (-XX:+UseConcMarkSweepGC) must be " | |
| 2053 "selected in order\nto use CMSIncrementalMode.\n"); | |
| 2054 status = false; | |
| 2055 } else { | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2056 status = status && verify_percentage(CMSIncrementalDutyCycle, |
| 0 | 2057 "CMSIncrementalDutyCycle"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2058 status = status && verify_percentage(CMSIncrementalDutyCycleMin, |
| 0 | 2059 "CMSIncrementalDutyCycleMin"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2060 status = status && verify_percentage(CMSIncrementalSafetyFactor, |
| 0 | 2061 "CMSIncrementalSafetyFactor"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2062 status = status && verify_percentage(CMSIncrementalOffset, |
| 0 | 2063 "CMSIncrementalOffset"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2064 status = status && verify_percentage(CMSExpAvgFactor, |
| 0 | 2065 "CMSExpAvgFactor"); |
| 2066 // If it was not set on the command line, set | |
| 2067 // CMSInitiatingOccupancyFraction to 1 so icms can initiate cycles early. | |
| 2068 if (CMSInitiatingOccupancyFraction < 0) { | |
| 2069 FLAG_SET_DEFAULT(CMSInitiatingOccupancyFraction, 1); | |
| 2070 } | |
| 2071 } | |
| 2072 } | |
| 2073 | |
| 2074 // CMS space iteration, which FLSVerifyAllHeapreferences entails, | |
| 2075 // insists that we hold the requisite locks so that the iteration is | |
| 2076 // MT-safe. For the verification at start-up and shut-down, we don't | |
| 2077 // yet have a good way of acquiring and releasing these locks, | |
| 2078 // which are not visible at the CollectedHeap level. We want to | |
| 2079 // be able to acquire these locks and then do the iteration rather | |
| 2080 // than just disable the lock verification. This will be fixed under | |
| 2081 // bug 4788986. | |
| 2082 if (UseConcMarkSweepGC && FLSVerifyAllHeapReferences) { | |
|
9071
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8859
diff
changeset
|
2083 if (VerifyDuringStartup) { |
| 0 | 2084 warning("Heap verification at start-up disabled " |
| 2085 "(due to current incompatibility with FLSVerifyAllHeapReferences)"); | |
|
9071
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8859
diff
changeset
|
2086 VerifyDuringStartup = false; // Disable verification at start-up |
| 0 | 2087 } |
|
9071
68fe50d4f1d5
8011343: Add new flag for verifying the heap during startup
johnc
parents:
8859
diff
changeset
|
2088 |
| 0 | 2089 if (VerifyBeforeExit) { |
| 2090 warning("Heap verification at shutdown disabled " | |
| 2091 "(due to current incompatibility with FLSVerifyAllHeapReferences)"); | |
| 2092 VerifyBeforeExit = false; // Disable verification at shutdown | |
| 2093 } | |
| 2094 } | |
| 2095 | |
| 2096 // Note: only executed in non-PRODUCT mode | |
| 2097 if (!UseAsyncConcMarkSweepGC && | |
| 2098 (ExplicitGCInvokesConcurrent || | |
| 2099 ExplicitGCInvokesConcurrentAndUnloadsClasses)) { | |
| 2100 jio_fprintf(defaultStream::error_stream(), | |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6266
diff
changeset
|
2101 "error: +ExplicitGCInvokesConcurrent[AndUnloadsClasses] conflicts" |
| 0 | 2102 " with -UseAsyncConcMarkSweepGC"); |
| 2103 status = false; | |
| 2104 } | |
| 2105 | |
|
2366
1fb790245268
6820066: Check that -XX:ParGCArrayScanChunk has a value larger than zero.
jwilhelm
parents:
2362
diff
changeset
|
2106 status = status && verify_min_value(ParGCArrayScanChunk, 1, "ParGCArrayScanChunk"); |
|
1fb790245268
6820066: Check that -XX:ParGCArrayScanChunk has a value larger than zero.
jwilhelm
parents:
2362
diff
changeset
|
2107 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
2108 #if INCLUDE_ALL_GCS |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
2109 if (UseG1GC) { |
|
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
2110 status = status && verify_percentage(InitiatingHeapOccupancyPercent, |
|
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
2111 "InitiatingHeapOccupancyPercent"); |
|
2174
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
2112 status = status && verify_min_value(G1RefProcDrainInterval, 1, |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
2113 "G1RefProcDrainInterval"); |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
2114 status = status && verify_min_value((intx)G1ConcMarkStepDurationMillis, 1, |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
2115 "G1ConcMarkStepDurationMillis"); |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10241
diff
changeset
|
2116 status = status && verify_interval(G1ConcRSHotCardLimit, 0, max_jubyte, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10241
diff
changeset
|
2117 "G1ConcRSHotCardLimit"); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10241
diff
changeset
|
2118 status = status && verify_interval(G1ConcRSLogCacheSize, 0, 31, |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10241
diff
changeset
|
2119 "G1ConcRSLogCacheSize"); |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
2120 } |
|
10287
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2121 if (UseConcMarkSweepGC) { |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2122 status = status && verify_min_value(CMSOldPLABNumRefills, 1, "CMSOldPLABNumRefills"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2123 status = status && verify_min_value(CMSOldPLABToleranceFactor, 1, "CMSOldPLABToleranceFactor"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2124 status = status && verify_min_value(CMSOldPLABMax, 1, "CMSOldPLABMax"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2125 status = status && verify_interval(CMSOldPLABMin, 1, CMSOldPLABMax, "CMSOldPLABMin"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2126 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2127 status = status && verify_min_value(CMSYoungGenPerWorker, 1, "CMSYoungGenPerWorker"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2128 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2129 status = status && verify_min_value(CMSSamplingGrain, 1, "CMSSamplingGrain"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2130 status = status && verify_interval(CMS_SweepWeight, 0, 100, "CMS_SweepWeight"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2131 status = status && verify_interval(CMS_FLSWeight, 0, 100, "CMS_FLSWeight"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2132 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2133 status = status && verify_interval(FLSCoalescePolicy, 0, 4, "FLSCoalescePolicy"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2134 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2135 status = status && verify_min_value(CMSRescanMultiple, 1, "CMSRescanMultiple"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2136 status = status && verify_min_value(CMSConcMarkMultiple, 1, "CMSConcMarkMultiple"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2137 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2138 status = status && verify_interval(CMSPrecleanIter, 0, 9, "CMSPrecleanIter"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2139 status = status && verify_min_value(CMSPrecleanDenominator, 1, "CMSPrecleanDenominator"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2140 status = status && verify_interval(CMSPrecleanNumerator, 0, CMSPrecleanDenominator - 1, "CMSPrecleanNumerator"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2141 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2142 status = status && verify_percentage(CMSBootstrapOccupancy, "CMSBootstrapOccupancy"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2143 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2144 status = status && verify_min_value(CMSPrecleanThreshold, 100, "CMSPrecleanThreshold"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2145 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2146 status = status && verify_percentage(CMSScheduleRemarkEdenPenetration, "CMSScheduleRemarkEdenPenetration"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2147 status = status && verify_min_value(CMSScheduleRemarkSamplingRatio, 1, "CMSScheduleRemarkSamplingRatio"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2148 status = status && verify_min_value(CMSBitMapYieldQuantum, 1, "CMSBitMapYieldQuantum"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2149 status = status && verify_percentage(CMSTriggerRatio, "CMSTriggerRatio"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2150 status = status && verify_percentage(CMSIsTooFullPercentage, "CMSIsTooFullPercentage"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2151 } |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2152 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2153 if (UseParallelGC || UseParallelOldGC) { |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2154 status = status && verify_interval(ParallelOldDeadWoodLimiterMean, 0, 100, "ParallelOldDeadWoodLimiterMean"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2155 status = status && verify_interval(ParallelOldDeadWoodLimiterStdDev, 0, 100, "ParallelOldDeadWoodLimiterStdDev"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2156 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2157 status = status && verify_percentage(YoungGenerationSizeIncrement, "YoungGenerationSizeIncrement"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2158 status = status && verify_percentage(TenuredGenerationSizeIncrement, "TenuredGenerationSizeIncrement"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2159 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2160 status = status && verify_min_value(YoungGenerationSizeSupplementDecay, 1, "YoungGenerationSizeSupplementDecay"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2161 status = status && verify_min_value(TenuredGenerationSizeSupplementDecay, 1, "TenuredGenerationSizeSupplementDecay"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2162 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2163 status = status && verify_min_value(ParGCCardsPerStrideChunk, 1, "ParGCCardsPerStrideChunk"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2164 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2165 status = status && verify_min_value(ParallelOldGCSplitInterval, 0, "ParallelOldGCSplitInterval"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2166 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
2167 #endif // INCLUDE_ALL_GCS |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
2168 |
|
1244
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2169 status = status && verify_interval(RefDiscoveryPolicy, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2170 ReferenceProcessor::DiscoveryPolicyMin, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2171 ReferenceProcessor::DiscoveryPolicyMax, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2172 "RefDiscoveryPolicy"); |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2173 |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2174 // Limit the lower bound of this flag to 1 as it is used in a division |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2175 // expression. |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2176 status = status && verify_interval(TLABWasteTargetPercent, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2177 1, 100, "TLABWasteTargetPercent"); |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
2178 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
2179 status = status && verify_object_alignment(); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
2180 |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
2181 status = status && verify_interval(CompressedClassSpaceSize, 1*M, 3*G, |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
2182 "CompressedClassSpaceSize"); |
|
6736
11fb740ce98f
7196103: NPG: Unable to allocate bit map for parallel garbage collection for the requested heap size
coleenp
parents:
6725
diff
changeset
|
2183 |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
2184 status = status && verify_interval(MarkStackSizeMax, |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7177
diff
changeset
|
2185 1, (max_jint - 1), "MarkStackSizeMax"); |
|
10287
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2186 status = status && verify_interval(NUMAChunkResizeWeight, 0, 100, "NUMAChunkResizeWeight"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2187 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2188 status = status && verify_min_value(LogEventsBufferEntries, 1, "LogEventsBufferEntries"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2189 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2190 status = status && verify_min_value(HeapSizePerGCThread, (uintx) os::vm_page_size(), "HeapSizePerGCThread"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2191 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2192 status = status && verify_min_value(GCTaskTimeStampEntries, 1, "GCTaskTimeStampEntries"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2193 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2194 status = status && verify_percentage(ParallelGCBufferWastePct, "ParallelGCBufferWastePct"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2195 status = status && verify_interval(TargetPLABWastePct, 1, 100, "TargetPLABWastePct"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2196 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2197 status = status && verify_min_value(ParGCStridesPerThread, 1, "ParGCStridesPerThread"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2198 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2199 status = status && verify_min_value(MinRAMFraction, 1, "MinRAMFraction"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2200 status = status && verify_min_value(InitialRAMFraction, 1, "InitialRAMFraction"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2201 status = status && verify_min_value(MaxRAMFraction, 1, "MaxRAMFraction"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2202 status = status && verify_min_value(DefaultMaxRAMFraction, 1, "DefaultMaxRAMFraction"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2203 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2204 status = status && verify_interval(AdaptiveTimeWeight, 0, 100, "AdaptiveTimeWeight"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2205 status = status && verify_min_value(AdaptiveSizeDecrementScaleFactor, 1, "AdaptiveSizeDecrementScaleFactor"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2206 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2207 status = status && verify_interval(TLABAllocationWeight, 0, 100, "TLABAllocationWeight"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2208 status = status && verify_min_value(MinTLABSize, 1, "MinTLABSize"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2209 status = status && verify_min_value(TLABRefillWasteFraction, 1, "TLABRefillWasteFraction"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2210 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2211 status = status && verify_percentage(YoungGenerationSizeSupplement, "YoungGenerationSizeSupplement"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2212 status = status && verify_percentage(TenuredGenerationSizeSupplement, "TenuredGenerationSizeSupplement"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2213 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2214 // the "age" field in the oop header is 4 bits; do not want to pull in markOop.hpp |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2215 // just for that, so hardcode here. |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2216 status = status && verify_interval(MaxTenuringThreshold, 0, 15, "MaxTenuringThreshold"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2217 status = status && verify_interval(InitialTenuringThreshold, 0, MaxTenuringThreshold, "MaxTenuringThreshold"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2218 status = status && verify_percentage(TargetSurvivorRatio, "TargetSurvivorRatio"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2219 status = status && verify_percentage(MarkSweepDeadRatio, "MarkSweepDeadRatio"); |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2220 |
|
12f651e29f6b
6843347: Boundary values in some public GC options cause crashes
tschatzl
parents:
10246
diff
changeset
|
2221 status = status && verify_min_value(MarkSweepAlwaysCompactCount, 1, "MarkSweepAlwaysCompactCount"); |
|
6755
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2222 #ifdef SPARC |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2223 if (UseConcMarkSweepGC || UseG1GC) { |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2224 // Issue a stern warning if the user has explicitly set |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2225 // UseMemSetInBOT (it is known to cause issues), but allow |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2226 // use for experimentation and debugging. |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2227 if (VM_Version::is_sun4v() && UseMemSetInBOT) { |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2228 assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error"); |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2229 warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability" |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2230 " on sun4v; please understand that you are using at your own risk!"); |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2231 } |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2232 } |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2233 #endif // SPARC |
|
bc675e55b48c
7193946: Move warnings associated with UseMemSetInBOT flag
johnc
parents:
6736
diff
changeset
|
2234 |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2235 if (PrintNMTStatistics) { |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2236 #if INCLUDE_NMT |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2237 if (MemTracker::tracking_level() == MemTracker::NMT_off) { |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2238 #endif // INCLUDE_NMT |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2239 warning("PrintNMTStatistics is disabled, because native memory tracking is not enabled"); |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2240 PrintNMTStatistics = false; |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2241 #if INCLUDE_NMT |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2242 } |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2243 #endif |
|
6770
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6736
diff
changeset
|
2244 } |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6736
diff
changeset
|
2245 |
|
10260
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2246 // Need to limit the extent of the padding to reasonable size. |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2247 // 8K is well beyond the reasonable HW cache line size, even with the |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2248 // aggressive prefetching, while still leaving the room for segregating |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2249 // among the distinct pages. |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2250 if (ContendedPaddingWidth < 0 || ContendedPaddingWidth > 8192) { |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2251 jio_fprintf(defaultStream::error_stream(), |
| 12129 | 2252 "ContendedPaddingWidth=" INTX_FORMAT " must be in between %d and %d\n", |
|
10260
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2253 ContendedPaddingWidth, 0, 8192); |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2254 status = false; |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2255 } |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2256 |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2257 // Need to enforce the padding not to break the existing field alignments. |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2258 // It is sufficient to check against the largest type size. |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2259 if ((ContendedPaddingWidth % BytesPerLong) != 0) { |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2260 jio_fprintf(defaultStream::error_stream(), |
| 12129 | 2261 "ContendedPaddingWidth=" INTX_FORMAT " must be a multiple of %d\n", |
|
10260
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2262 ContendedPaddingWidth, BytesPerLong); |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2263 status = false; |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2264 } |
|
711016f146fd
8006997: ContendedPaddingWidth should be range-checked
dholmes
parents:
10172
diff
changeset
|
2265 |
|
11079
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2266 // Check lower bounds of the code cache |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2267 // Template Interpreter code is approximately 3X larger in debug builds. |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2268 uint min_code_cache_size = (CodeCacheMinimumUseSpace DEBUG_ONLY(* 3)) + CodeCacheMinimumFreeSpace; |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2269 if (InitialCodeCacheSize < (uintx)os::vm_page_size()) { |
|
10392
c07dd9be16e8
8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm.
anoll
parents:
10319
diff
changeset
|
2270 jio_fprintf(defaultStream::error_stream(), |
|
11079
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2271 "Invalid InitialCodeCacheSize=%dK. Must be at least %dK.\n", InitialCodeCacheSize/K, |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2272 os::vm_page_size()/K); |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2273 status = false; |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2274 } else if (ReservedCodeCacheSize < InitialCodeCacheSize) { |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2275 jio_fprintf(defaultStream::error_stream(), |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2276 "Invalid ReservedCodeCacheSize: %dK. Must be at least InitialCodeCacheSize=%dK.\n", |
|
10392
c07dd9be16e8
8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm.
anoll
parents:
10319
diff
changeset
|
2277 ReservedCodeCacheSize/K, InitialCodeCacheSize/K); |
|
c07dd9be16e8
8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm.
anoll
parents:
10319
diff
changeset
|
2278 status = false; |
|
11079
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2279 } else if (ReservedCodeCacheSize < min_code_cache_size) { |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2280 jio_fprintf(defaultStream::error_stream(), |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2281 "Invalid ReservedCodeCacheSize=%dK. Must be at least %uK.\n", ReservedCodeCacheSize/K, |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2282 min_code_cache_size/K); |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2283 status = false; |
|
11109
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
2284 } else if (ReservedCodeCacheSize > 2*G) { |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
2285 // Code cache size larger than MAXINT is not supported. |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
2286 jio_fprintf(defaultStream::error_stream(), |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
2287 "Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M, |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
2288 (2*G)/M); |
|
7ac80525ece9
8015635: Crash when specifying very large code cache size
anoll
parents:
11083
diff
changeset
|
2289 status = false; |
|
10392
c07dd9be16e8
8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm.
anoll
parents:
10319
diff
changeset
|
2290 } |
| 0 | 2291 return status; |
| 2292 } | |
| 2293 | |
| 2294 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore, | |
| 2295 const char* option_type) { | |
| 2296 if (ignore) return false; | |
| 2297 | |
| 2298 const char* spacer = " "; | |
| 2299 if (option_type == NULL) { | |
| 2300 option_type = ++spacer; // Set both to the empty string. | |
| 2301 } | |
| 2302 | |
| 2303 if (os::obsolete_option(option)) { | |
| 2304 jio_fprintf(defaultStream::error_stream(), | |
| 2305 "Obsolete %s%soption: %s\n", option_type, spacer, | |
| 2306 option->optionString); | |
| 2307 return false; | |
| 2308 } else { | |
| 2309 jio_fprintf(defaultStream::error_stream(), | |
| 2310 "Unrecognized %s%soption: %s\n", option_type, spacer, | |
| 2311 option->optionString); | |
| 2312 return true; | |
| 2313 } | |
| 2314 } | |
| 2315 | |
| 2316 static const char* user_assertion_options[] = { | |
| 2317 "-da", "-ea", "-disableassertions", "-enableassertions", 0 | |
| 2318 }; | |
| 2319 | |
| 2320 static const char* system_assertion_options[] = { | |
| 2321 "-dsa", "-esa", "-disablesystemassertions", "-enablesystemassertions", 0 | |
| 2322 }; | |
| 2323 | |
| 2324 // Return true if any of the strings in null-terminated array 'names' matches. | |
| 2325 // If tail_allowed is true, then the tail must begin with a colon; otherwise, | |
| 2326 // the option must match exactly. | |
| 2327 static bool match_option(const JavaVMOption* option, const char** names, const char** tail, | |
| 2328 bool tail_allowed) { | |
| 2329 for (/* empty */; *names != NULL; ++names) { | |
| 2330 if (match_option(option, *names, tail)) { | |
| 2331 if (**tail == '\0' || tail_allowed && **tail == ':') { | |
| 2332 return true; | |
| 2333 } | |
| 2334 } | |
| 2335 } | |
| 2336 return false; | |
| 2337 } | |
| 2338 | |
| 1284 | 2339 bool Arguments::parse_uintx(const char* value, |
| 2340 uintx* uintx_arg, | |
| 2341 uintx min_size) { | |
| 2342 | |
| 2343 // Check the sign first since atomull() parses only unsigned values. | |
| 2344 bool value_is_positive = !(*value == '-'); | |
| 2345 | |
| 2346 if (value_is_positive) { | |
| 2347 julong n; | |
| 2348 bool good_return = atomull(value, &n); | |
| 2349 if (good_return) { | |
| 2350 bool above_minimum = n >= min_size; | |
| 2351 bool value_is_too_large = n > max_uintx; | |
| 2352 | |
| 2353 if (above_minimum && !value_is_too_large) { | |
| 2354 *uintx_arg = n; | |
| 2355 return true; | |
| 2356 } | |
| 2357 } | |
| 2358 } | |
| 2359 return false; | |
| 2360 } | |
| 2361 | |
| 0 | 2362 Arguments::ArgsRange Arguments::parse_memory_size(const char* s, |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2363 julong* long_arg, |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2364 julong min_size) { |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2365 if (!atomull(s, long_arg)) return arg_unreadable; |
| 0 | 2366 return check_memory_size(*long_arg, min_size); |
| 2367 } | |
| 2368 | |
| 2369 // Parse JavaVMInitArgs structure | |
| 2370 | |
| 2371 jint Arguments::parse_vm_init_args(const JavaVMInitArgs* args) { | |
| 2372 // For components of the system classpath. | |
| 2373 SysClassPath scp(Arguments::get_sysclasspath()); | |
| 2374 bool scp_assembly_required = false; | |
| 2375 | |
| 2376 // Save default settings for some mode flags | |
| 2377 Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods; | |
| 2378 Arguments::_UseOnStackReplacement = UseOnStackReplacement; | |
| 2379 Arguments::_ClipInlining = ClipInlining; | |
| 2380 Arguments::_BackgroundCompilation = BackgroundCompilation; | |
| 2381 | |
|
3341
e9b8ef09622a
7041582: set_mode_flags isn't called without -Xmixed specified
never
parents:
3261
diff
changeset
|
2382 // Setup flags for mixed which is the default |
|
e9b8ef09622a
7041582: set_mode_flags isn't called without -Xmixed specified
never
parents:
3261
diff
changeset
|
2383 set_mode_flags(_mixed); |
|
e9b8ef09622a
7041582: set_mode_flags isn't called without -Xmixed specified
never
parents:
3261
diff
changeset
|
2384 |
| 0 | 2385 // Parse JAVA_TOOL_OPTIONS environment variable (if present) |
| 2386 jint result = parse_java_tool_options_environment_variable(&scp, &scp_assembly_required); | |
| 2387 if (result != JNI_OK) { | |
| 2388 return result; | |
| 2389 } | |
| 2390 | |
| 2391 // Parse JavaVMInitArgs structure passed in | |
| 2392 result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, COMMAND_LINE); | |
| 2393 if (result != JNI_OK) { | |
| 2394 return result; | |
| 2395 } | |
| 2396 | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2397 if (AggressiveOpts) { |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2398 // Insert alt-rt.jar between user-specified bootclasspath |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2399 // prefix and the default bootclasspath. os::set_boot_path() |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2400 // uses meta_index_dir as the default bootclasspath directory. |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2401 const char* altclasses_jar = "alt-rt.jar"; |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2402 size_t altclasses_path_len = strlen(get_meta_index_dir()) + 1 + |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2403 strlen(altclasses_jar); |
| 6197 | 2404 char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len, mtInternal); |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2405 strcpy(altclasses_path, get_meta_index_dir()); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2406 strcat(altclasses_path, altclasses_jar); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2407 scp.add_suffix_to_prefix(altclasses_path); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2408 scp_assembly_required = true; |
| 6197 | 2409 FREE_C_HEAP_ARRAY(char, altclasses_path, mtInternal); |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2410 } |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2411 |
| 0 | 2412 // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM) |
| 2413 result = parse_java_options_environment_variable(&scp, &scp_assembly_required); | |
| 2414 if (result != JNI_OK) { | |
| 2415 return result; | |
| 2416 } | |
| 2417 | |
| 2418 // Do final processing now that all arguments have been parsed | |
| 2419 result = finalize_vm_init_args(&scp, scp_assembly_required); | |
| 2420 if (result != JNI_OK) { | |
| 2421 return result; | |
| 2422 } | |
| 2423 | |
| 2424 return JNI_OK; | |
| 2425 } | |
| 2426 | |
|
10170
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2427 // Checks if name in command-line argument -agent{lib,path}:name[=options] |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2428 // represents a valid HPROF of JDWP agent. is_path==true denotes that we |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2429 // are dealing with -agentpath (case where name is a path), otherwise with |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2430 // -agentlib |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2431 bool valid_hprof_or_jdwp_agent(char *name, bool is_path) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2432 char *_name; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2433 const char *_hprof = "hprof", *_jdwp = "jdwp"; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2434 size_t _len_hprof, _len_jdwp, _len_prefix; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2435 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2436 if (is_path) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2437 if ((_name = strrchr(name, (int) *os::file_separator())) == NULL) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2438 return false; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2439 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2440 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2441 _name++; // skip past last path separator |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2442 _len_prefix = strlen(JNI_LIB_PREFIX); |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2443 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2444 if (strncmp(_name, JNI_LIB_PREFIX, _len_prefix) != 0) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2445 return false; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2446 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2447 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2448 _name += _len_prefix; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2449 _len_hprof = strlen(_hprof); |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2450 _len_jdwp = strlen(_jdwp); |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2451 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2452 if (strncmp(_name, _hprof, _len_hprof) == 0) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2453 _name += _len_hprof; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2454 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2455 else if (strncmp(_name, _jdwp, _len_jdwp) == 0) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2456 _name += _len_jdwp; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2457 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2458 else { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2459 return false; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2460 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2461 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2462 if (strcmp(_name, JNI_LIB_SUFFIX) != 0) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2463 return false; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2464 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2465 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2466 return true; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2467 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2468 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2469 if (strcmp(name, _hprof) == 0 || strcmp(name, _jdwp) == 0) { |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2470 return true; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2471 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2472 |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2473 return false; |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2474 } |
|
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2475 |
| 0 | 2476 jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, |
| 2477 SysClassPath* scp_p, | |
| 2478 bool* scp_assembly_required_p, | |
| 2479 FlagValueOrigin origin) { | |
| 2480 // Remaining part of option string | |
| 2481 const char* tail; | |
| 2482 | |
| 2483 // iterate over arguments | |
| 2484 for (int index = 0; index < args->nOptions; index++) { | |
| 2485 bool is_absolute_path = false; // for -agentpath vs -agentlib | |
| 2486 | |
| 2487 const JavaVMOption* option = args->options + index; | |
| 2488 | |
| 2489 if (!match_option(option, "-Djava.class.path", &tail) && | |
| 2490 !match_option(option, "-Dsun.java.command", &tail) && | |
| 2491 !match_option(option, "-Dsun.java.launcher", &tail)) { | |
| 2492 | |
| 2493 // add all jvm options to the jvm_args string. This string | |
| 2494 // is used later to set the java.vm.args PerfData string constant. | |
| 2495 // the -Djava.class.path and the -Dsun.java.command options are | |
| 2496 // omitted from jvm_args string as each have their own PerfData | |
| 2497 // string constant object. | |
| 2498 build_jvm_args(option->optionString); | |
| 2499 } | |
| 2500 | |
| 2501 // -verbose:[class/gc/jni] | |
| 2502 if (match_option(option, "-verbose", &tail)) { | |
| 2503 if (!strcmp(tail, ":class") || !strcmp(tail, "")) { | |
| 2504 FLAG_SET_CMDLINE(bool, TraceClassLoading, true); | |
| 2505 FLAG_SET_CMDLINE(bool, TraceClassUnloading, true); | |
| 2506 } else if (!strcmp(tail, ":gc")) { | |
| 2507 FLAG_SET_CMDLINE(bool, PrintGC, true); | |
| 2508 } else if (!strcmp(tail, ":jni")) { | |
| 2509 FLAG_SET_CMDLINE(bool, PrintJNIResolving, true); | |
| 2510 } | |
| 2511 // -da / -ea / -disableassertions / -enableassertions | |
| 2512 // These accept an optional class/package name separated by a colon, e.g., | |
| 2513 // -da:java.lang.Thread. | |
| 2514 } else if (match_option(option, user_assertion_options, &tail, true)) { | |
| 2515 bool enable = option->optionString[1] == 'e'; // char after '-' is 'e' | |
| 2516 if (*tail == '\0') { | |
| 2517 JavaAssertions::setUserClassDefault(enable); | |
| 2518 } else { | |
| 2519 assert(*tail == ':', "bogus match by match_option()"); | |
| 2520 JavaAssertions::addOption(tail + 1, enable); | |
| 2521 } | |
| 2522 // -dsa / -esa / -disablesystemassertions / -enablesystemassertions | |
| 2523 } else if (match_option(option, system_assertion_options, &tail, false)) { | |
| 2524 bool enable = option->optionString[1] == 'e'; // char after '-' is 'e' | |
| 2525 JavaAssertions::setSystemClassDefault(enable); | |
| 2526 // -bootclasspath: | |
| 2527 } else if (match_option(option, "-Xbootclasspath:", &tail)) { | |
| 2528 scp_p->reset_path(tail); | |
| 2529 *scp_assembly_required_p = true; | |
| 2530 // -bootclasspath/a: | |
| 2531 } else if (match_option(option, "-Xbootclasspath/a:", &tail)) { | |
| 2532 scp_p->add_suffix(tail); | |
| 2533 *scp_assembly_required_p = true; | |
| 2534 // -bootclasspath/p: | |
| 2535 } else if (match_option(option, "-Xbootclasspath/p:", &tail)) { | |
| 2536 scp_p->add_prefix(tail); | |
| 2537 *scp_assembly_required_p = true; | |
| 2538 // -Xrun | |
| 2539 } else if (match_option(option, "-Xrun", &tail)) { | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2540 if (tail != NULL) { |
| 0 | 2541 const char* pos = strchr(tail, ':'); |
| 2542 size_t len = (pos == NULL) ? strlen(tail) : pos - tail; | |
| 6197 | 2543 char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len); |
| 0 | 2544 name[len] = '\0'; |
| 2545 | |
| 2546 char *options = NULL; | |
| 2547 if(pos != NULL) { | |
| 2548 size_t len2 = strlen(pos+1) + 1; // options start after ':'. Final zero must be copied. | |
| 6197 | 2549 options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2); |
| 0 | 2550 } |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2551 #if !INCLUDE_JVMTI |
| 0 | 2552 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) { |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2553 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2554 "Profiling and debugging agents are not supported in this VM\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2555 return JNI_ERR; |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2556 } |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2557 #endif // !INCLUDE_JVMTI |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2558 add_init_library(name, options); |
| 0 | 2559 } |
| 2560 // -agentlib and -agentpath | |
| 2561 } else if (match_option(option, "-agentlib:", &tail) || | |
| 2562 (is_absolute_path = match_option(option, "-agentpath:", &tail))) { | |
| 2563 if(tail != NULL) { | |
| 2564 const char* pos = strchr(tail, '='); | |
| 2565 size_t len = (pos == NULL) ? strlen(tail) : pos - tail; | |
| 6197 | 2566 char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len); |
| 0 | 2567 name[len] = '\0'; |
| 2568 | |
| 2569 char *options = NULL; | |
| 2570 if(pos != NULL) { | |
| 6197 | 2571 options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1); |
| 0 | 2572 } |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2573 #if !INCLUDE_JVMTI |
|
10170
3c0584fec1e6
8010428: Special -agentpath checks needed with minimal VM to produce proper error message
dholmes
parents:
9077
diff
changeset
|
2574 if (valid_hprof_or_jdwp_agent(name, is_absolute_path)) { |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2575 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2576 "Profiling and debugging agents are not supported in this VM\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2577 return JNI_ERR; |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2578 } |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2579 #endif // !INCLUDE_JVMTI |
| 0 | 2580 add_init_agent(name, options, is_absolute_path); |
| 2581 } | |
| 2582 // -javaagent | |
| 2583 } else if (match_option(option, "-javaagent:", &tail)) { | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2584 #if !INCLUDE_JVMTI |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2585 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2586 "Instrumentation agents are not supported in this VM\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2587 return JNI_ERR; |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2588 #else |
| 0 | 2589 if(tail != NULL) { |
| 6197 | 2590 char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail); |
| 0 | 2591 add_init_agent("instrument", options, false); |
| 2592 } | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2593 #endif // !INCLUDE_JVMTI |
| 0 | 2594 // -Xnoclassgc |
| 2595 } else if (match_option(option, "-Xnoclassgc", &tail)) { | |
| 2596 FLAG_SET_CMDLINE(bool, ClassUnloading, false); | |
| 2597 // -Xincgc: i-CMS | |
| 2598 } else if (match_option(option, "-Xincgc", &tail)) { | |
| 2599 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true); | |
| 2600 FLAG_SET_CMDLINE(bool, CMSIncrementalMode, true); | |
| 2601 // -Xnoincgc: no i-CMS | |
| 2602 } else if (match_option(option, "-Xnoincgc", &tail)) { | |
| 2603 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, false); | |
| 2604 FLAG_SET_CMDLINE(bool, CMSIncrementalMode, false); | |
| 2605 // -Xconcgc | |
| 2606 } else if (match_option(option, "-Xconcgc", &tail)) { | |
| 2607 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true); | |
| 2608 // -Xnoconcgc | |
| 2609 } else if (match_option(option, "-Xnoconcgc", &tail)) { | |
| 2610 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, false); | |
| 2611 // -Xbatch | |
| 2612 } else if (match_option(option, "-Xbatch", &tail)) { | |
| 2613 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); | |
| 2614 // -Xmn for compatibility with other JVM vendors | |
| 2615 } else if (match_option(option, "-Xmn", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2616 julong long_initial_eden_size = 0; |
| 0 | 2617 ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1); |
| 2618 if (errcode != arg_in_range) { | |
| 2619 jio_fprintf(defaultStream::error_stream(), | |
| 2620 "Invalid initial eden size: %s\n", option->optionString); | |
| 2621 describe_range_error(errcode); | |
| 2622 return JNI_EINVAL; | |
| 2623 } | |
| 1064 | 2624 FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size); |
| 2625 FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size); | |
| 0 | 2626 // -Xms |
| 2627 } else if (match_option(option, "-Xms", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2628 julong long_initial_heap_size = 0; |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
2629 // an initial heap size of 0 means automatically determine |
|
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
2630 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 0); |
| 0 | 2631 if (errcode != arg_in_range) { |
| 2632 jio_fprintf(defaultStream::error_stream(), | |
| 2633 "Invalid initial heap size: %s\n", option->optionString); | |
| 2634 describe_range_error(errcode); | |
| 2635 return JNI_EINVAL; | |
| 2636 } | |
| 1064 | 2637 FLAG_SET_CMDLINE(uintx, InitialHeapSize, (uintx)long_initial_heap_size); |
| 0 | 2638 // Currently the minimum size and the initial heap sizes are the same. |
| 1064 | 2639 set_min_heap_size(InitialHeapSize); |
| 0 | 2640 // -Xmx |
|
10241
d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
tschatzl
parents:
10240
diff
changeset
|
2641 } else if (match_option(option, "-Xmx", &tail) || match_option(option, "-XX:MaxHeapSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2642 julong long_max_heap_size = 0; |
| 0 | 2643 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1); |
| 2644 if (errcode != arg_in_range) { | |
| 2645 jio_fprintf(defaultStream::error_stream(), | |
| 2646 "Invalid maximum heap size: %s\n", option->optionString); | |
| 2647 describe_range_error(errcode); | |
| 2648 return JNI_EINVAL; | |
| 2649 } | |
| 1064 | 2650 FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size); |
| 0 | 2651 // Xmaxf |
| 2652 } else if (match_option(option, "-Xmaxf", &tail)) { | |
| 2653 int maxf = (int)(atof(tail) * 100); | |
| 2654 if (maxf < 0 || maxf > 100) { | |
| 2655 jio_fprintf(defaultStream::error_stream(), | |
| 2656 "Bad max heap free percentage size: %s\n", | |
| 2657 option->optionString); | |
| 2658 return JNI_EINVAL; | |
| 2659 } else { | |
| 2660 FLAG_SET_CMDLINE(uintx, MaxHeapFreeRatio, maxf); | |
| 2661 } | |
| 2662 // Xminf | |
| 2663 } else if (match_option(option, "-Xminf", &tail)) { | |
| 2664 int minf = (int)(atof(tail) * 100); | |
| 2665 if (minf < 0 || minf > 100) { | |
| 2666 jio_fprintf(defaultStream::error_stream(), | |
| 2667 "Bad min heap free percentage size: %s\n", | |
| 2668 option->optionString); | |
| 2669 return JNI_EINVAL; | |
| 2670 } else { | |
| 2671 FLAG_SET_CMDLINE(uintx, MinHeapFreeRatio, minf); | |
| 2672 } | |
| 2673 // -Xss | |
| 2674 } else if (match_option(option, "-Xss", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2675 julong long_ThreadStackSize = 0; |
| 0 | 2676 ArgsRange errcode = parse_memory_size(tail, &long_ThreadStackSize, 1000); |
| 2677 if (errcode != arg_in_range) { | |
| 2678 jio_fprintf(defaultStream::error_stream(), | |
| 2679 "Invalid thread stack size: %s\n", option->optionString); | |
| 2680 describe_range_error(errcode); | |
| 2681 return JNI_EINVAL; | |
| 2682 } | |
| 2683 // Internally track ThreadStackSize in units of 1024 bytes. | |
| 2684 FLAG_SET_CMDLINE(intx, ThreadStackSize, | |
| 2685 round_to((int)long_ThreadStackSize, K) / K); | |
| 2686 // -Xoss | |
| 2687 } else if (match_option(option, "-Xoss", &tail)) { | |
| 2688 // HotSpot does not have separate native and Java stacks, ignore silently for compatibility | |
|
11079
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2689 } else if (match_option(option, "-XX:CodeCacheExpansionSize=", &tail)) { |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2690 julong long_CodeCacheExpansionSize = 0; |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2691 ArgsRange errcode = parse_memory_size(tail, &long_CodeCacheExpansionSize, os::vm_page_size()); |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2692 if (errcode != arg_in_range) { |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2693 jio_fprintf(defaultStream::error_stream(), |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2694 "Invalid argument: %s. Must be at least %luK.\n", option->optionString, |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2695 os::vm_page_size()/K); |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2696 return JNI_EINVAL; |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2697 } |
|
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2698 FLAG_SET_CMDLINE(uintx, CodeCacheExpansionSize, (uintx)long_CodeCacheExpansionSize); |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2002
diff
changeset
|
2699 } else if (match_option(option, "-Xmaxjitcodesize", &tail) || |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2002
diff
changeset
|
2700 match_option(option, "-XX:ReservedCodeCacheSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2701 julong long_ReservedCodeCacheSize = 0; |
|
11079
738e04fb1232
8014972: Crash with specific values for -XX:InitialCodeCacheSize=500K -XX:ReservedCodeCacheSize=500k
anoll
parents:
11006
diff
changeset
|
2702 |
|
10392
c07dd9be16e8
8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm.
anoll
parents:
10319
diff
changeset
|
2703 ArgsRange errcode = parse_memory_size(tail, &long_ReservedCodeCacheSize, 1); |
| 0 | 2704 if (errcode != arg_in_range) { |
| 2705 jio_fprintf(defaultStream::error_stream(), | |
|
10392
c07dd9be16e8
8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm.
anoll
parents:
10319
diff
changeset
|
2706 "Invalid maximum code cache size: %s.\n", option->optionString); |
| 0 | 2707 return JNI_EINVAL; |
| 2708 } | |
| 2709 FLAG_SET_CMDLINE(uintx, ReservedCodeCacheSize, (uintx)long_ReservedCodeCacheSize); | |
|
10319
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2710 //-XX:IncreaseFirstTierCompileThresholdAt= |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2711 } else if (match_option(option, "-XX:IncreaseFirstTierCompileThresholdAt=", &tail)) { |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2712 uintx uint_IncreaseFirstTierCompileThresholdAt = 0; |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2713 if (!parse_uintx(tail, &uint_IncreaseFirstTierCompileThresholdAt, 0) || uint_IncreaseFirstTierCompileThresholdAt > 99) { |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2714 jio_fprintf(defaultStream::error_stream(), |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2715 "Invalid value for IncreaseFirstTierCompileThresholdAt: %s. Should be between 0 and 99.\n", |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2716 option->optionString); |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2717 return JNI_EINVAL; |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2718 } |
|
91eba9f82325
8012371: Adjust Tiered compile threshold according to available space in code cache
anoll
parents:
10294
diff
changeset
|
2719 FLAG_SET_CMDLINE(uintx, IncreaseFirstTierCompileThresholdAt, (uintx)uint_IncreaseFirstTierCompileThresholdAt); |
| 0 | 2720 // -green |
| 2721 } else if (match_option(option, "-green", &tail)) { | |
| 2722 jio_fprintf(defaultStream::error_stream(), | |
| 2723 "Green threads support not available\n"); | |
| 2724 return JNI_EINVAL; | |
| 2725 // -native | |
| 2726 } else if (match_option(option, "-native", &tail)) { | |
| 2727 // HotSpot always uses native threads, ignore silently for compatibility | |
| 2728 // -Xsqnopause | |
| 2729 } else if (match_option(option, "-Xsqnopause", &tail)) { | |
| 2730 // EVM option, ignore silently for compatibility | |
| 2731 // -Xrs | |
| 2732 } else if (match_option(option, "-Xrs", &tail)) { | |
| 2733 // Classic/EVM option, new functionality | |
| 2734 FLAG_SET_CMDLINE(bool, ReduceSignalUsage, true); | |
| 2735 } else if (match_option(option, "-Xusealtsigs", &tail)) { | |
| 2736 // change default internal VM signals used - lower case for back compat | |
| 2737 FLAG_SET_CMDLINE(bool, UseAltSigs, true); | |
| 2738 // -Xoptimize | |
| 2739 } else if (match_option(option, "-Xoptimize", &tail)) { | |
| 2740 // EVM option, ignore silently for compatibility | |
| 2741 // -Xprof | |
| 2742 } else if (match_option(option, "-Xprof", &tail)) { | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2743 #if INCLUDE_FPROF |
| 0 | 2744 _has_profile = true; |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2745 #else // INCLUDE_FPROF |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2746 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2747 "Flat profiling is not supported in this VM.\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2748 return JNI_ERR; |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2749 #endif // INCLUDE_FPROF |
| 0 | 2750 // -Xconcurrentio |
| 2751 } else if (match_option(option, "-Xconcurrentio", &tail)) { | |
| 2752 FLAG_SET_CMDLINE(bool, UseLWPSynchronization, true); | |
| 2753 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); | |
| 2754 FLAG_SET_CMDLINE(intx, DeferThrSuspendLoopCount, 1); | |
| 2755 FLAG_SET_CMDLINE(bool, UseTLAB, false); | |
| 2756 FLAG_SET_CMDLINE(uintx, NewSizeThreadIncrease, 16 * K); // 20Kb per thread added to new generation | |
| 2757 | |
| 2758 // -Xinternalversion | |
| 2759 } else if (match_option(option, "-Xinternalversion", &tail)) { | |
| 2760 jio_fprintf(defaultStream::output_stream(), "%s\n", | |
| 2761 VM_Version::internal_vm_info_string()); | |
| 2762 vm_exit(0); | |
| 2763 #ifndef PRODUCT | |
| 2764 // -Xprintflags | |
| 2765 } else if (match_option(option, "-Xprintflags", &tail)) { | |
| 4773 | 2766 CommandLineFlags::printFlags(tty, false); |
| 0 | 2767 vm_exit(0); |
| 2768 #endif | |
| 2769 // -D | |
| 2770 } else if (match_option(option, "-D", &tail)) { | |
| 2771 if (!add_property(tail)) { | |
| 2772 return JNI_ENOMEM; | |
| 2773 } | |
| 2774 // Out of the box management support | |
| 2775 if (match_option(option, "-Dcom.sun.management", &tail)) { | |
|
8081
579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
jprovino
parents:
8002
diff
changeset
|
2776 #if INCLUDE_MANAGEMENT |
| 0 | 2777 FLAG_SET_CMDLINE(bool, ManagementServer, true); |
|
8081
579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
jprovino
parents:
8002
diff
changeset
|
2778 #else |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2779 jio_fprintf(defaultStream::output_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2780 "-Dcom.sun.management is not supported in this VM.\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
2781 return JNI_ERR; |
|
8081
579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
jprovino
parents:
8002
diff
changeset
|
2782 #endif |
| 0 | 2783 } |
| 2784 // -Xint | |
| 2785 } else if (match_option(option, "-Xint", &tail)) { | |
| 2786 set_mode_flags(_int); | |
| 2787 // -Xmixed | |
| 2788 } else if (match_option(option, "-Xmixed", &tail)) { | |
| 2789 set_mode_flags(_mixed); | |
| 2790 // -Xcomp | |
| 2791 } else if (match_option(option, "-Xcomp", &tail)) { | |
| 2792 // for testing the compiler; turn off all flags that inhibit compilation | |
| 2793 set_mode_flags(_comp); | |
| 2794 // -Xshare:dump | |
| 2795 } else if (match_option(option, "-Xshare:dump", &tail)) { | |
| 2796 FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true); | |
| 2797 set_mode_flags(_int); // Prevent compilation, which creates objects | |
| 2798 // -Xshare:on | |
| 2799 } else if (match_option(option, "-Xshare:on", &tail)) { | |
| 2800 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true); | |
| 2801 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, true); | |
| 2802 // -Xshare:auto | |
| 2803 } else if (match_option(option, "-Xshare:auto", &tail)) { | |
| 2804 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true); | |
| 2805 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false); | |
| 2806 // -Xshare:off | |
| 2807 } else if (match_option(option, "-Xshare:off", &tail)) { | |
| 2808 FLAG_SET_CMDLINE(bool, UseSharedSpaces, false); | |
| 2809 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false); | |
| 2810 // -Xverify | |
| 2811 } else if (match_option(option, "-Xverify", &tail)) { | |
| 2812 if (strcmp(tail, ":all") == 0 || strcmp(tail, "") == 0) { | |
| 2813 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, true); | |
| 2814 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true); | |
| 2815 } else if (strcmp(tail, ":remote") == 0) { | |
| 2816 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, false); | |
| 2817 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true); | |
| 2818 } else if (strcmp(tail, ":none") == 0) { | |
| 2819 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, false); | |
| 2820 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, false); | |
| 2821 } else if (is_bad_option(option, args->ignoreUnrecognized, "verification")) { | |
| 2822 return JNI_EINVAL; | |
| 2823 } | |
| 2824 // -Xdebug | |
| 2825 } else if (match_option(option, "-Xdebug", &tail)) { | |
| 2826 // note this flag has been used, then ignore | |
| 2827 set_xdebug_mode(true); | |
| 2828 // -Xnoagent | |
| 2829 } else if (match_option(option, "-Xnoagent", &tail)) { | |
| 2830 // For compatibility with classic. HotSpot refuses to load the old style agent.dll. | |
| 2831 } else if (match_option(option, "-Xboundthreads", &tail)) { | |
| 2832 // Bind user level threads to kernel threads (Solaris only) | |
| 2833 FLAG_SET_CMDLINE(bool, UseBoundThreads, true); | |
| 2834 } else if (match_option(option, "-Xloggc:", &tail)) { | |
| 2835 // Redirect GC output to the file. -Xloggc:<filename> | |
| 2836 // ostream_init_log(), when called will use this filename | |
| 2837 // to initialize a fileStream. | |
| 2838 _gc_log_filename = strdup(tail); | |
| 2839 FLAG_SET_CMDLINE(bool, PrintGC, true); | |
| 2840 FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true); | |
| 2841 | |
| 2842 // JNI hooks | |
| 2843 } else if (match_option(option, "-Xcheck", &tail)) { | |
| 2844 if (!strcmp(tail, ":jni")) { | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2845 #if !INCLUDE_JNI_CHECK |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2846 warning("JNI CHECKING is not supported in this VM"); |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2847 #else |
| 0 | 2848 CheckJNICalls = true; |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
2849 #endif // INCLUDE_JNI_CHECK |
| 0 | 2850 } else if (is_bad_option(option, args->ignoreUnrecognized, |
| 2851 "check")) { | |
| 2852 return JNI_EINVAL; | |
| 2853 } | |
| 2854 } else if (match_option(option, "vfprintf", &tail)) { | |
| 2855 _vfprintf_hook = CAST_TO_FN_PTR(vfprintf_hook_t, option->extraInfo); | |
| 2856 } else if (match_option(option, "exit", &tail)) { | |
| 2857 _exit_hook = CAST_TO_FN_PTR(exit_hook_t, option->extraInfo); | |
| 2858 } else if (match_option(option, "abort", &tail)) { | |
| 2859 _abort_hook = CAST_TO_FN_PTR(abort_hook_t, option->extraInfo); | |
| 2860 // -XX:+AggressiveHeap | |
| 2861 } else if (match_option(option, "-XX:+AggressiveHeap", &tail)) { | |
| 2862 | |
| 2863 // This option inspects the machine and attempts to set various | |
| 2864 // parameters to be optimal for long-running, memory allocation | |
| 2865 // intensive jobs. It is intended for machines with large | |
| 2866 // amounts of cpu and memory. | |
| 2867 | |
| 2868 // initHeapSize is needed since _initial_heap_size is 4 bytes on a 32 bit | |
| 2869 // VM, but we may not be able to represent the total physical memory | |
| 2870 // available (like having 8gb of memory on a box but using a 32bit VM). | |
| 2871 // Thus, we need to make sure we're using a julong for intermediate | |
| 2872 // calculations. | |
| 2873 julong initHeapSize; | |
| 2874 julong total_memory = os::physical_memory(); | |
| 2875 | |
| 2876 if (total_memory < (julong)256*M) { | |
| 2877 jio_fprintf(defaultStream::error_stream(), | |
| 2878 "You need at least 256mb of memory to use -XX:+AggressiveHeap\n"); | |
| 2879 vm_exit(1); | |
| 2880 } | |
| 2881 | |
| 2882 // The heap size is half of available memory, or (at most) | |
| 2883 // all of possible memory less 160mb (leaving room for the OS | |
| 2884 // when using ISM). This is the maximum; because adaptive sizing | |
| 2885 // is turned on below, the actual space used may be smaller. | |
| 2886 | |
| 2887 initHeapSize = MIN2(total_memory / (julong)2, | |
| 2888 total_memory - (julong)160*M); | |
| 2889 | |
|
8854
754c24457b20
7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
tschatzl
parents:
8824
diff
changeset
|
2890 initHeapSize = limit_by_allocatable_memory(initHeapSize); |
| 0 | 2891 |
| 2892 if (FLAG_IS_DEFAULT(MaxHeapSize)) { | |
| 2893 FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize); | |
| 1064 | 2894 FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize); |
| 0 | 2895 // Currently the minimum size and the initial heap sizes are the same. |
| 1064 | 2896 set_min_heap_size(initHeapSize); |
| 0 | 2897 } |
| 2898 if (FLAG_IS_DEFAULT(NewSize)) { | |
| 2899 // Make the young generation 3/8ths of the total heap. | |
| 2900 FLAG_SET_CMDLINE(uintx, NewSize, | |
| 2901 ((julong)MaxHeapSize / (julong)8) * (julong)3); | |
| 2902 FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize); | |
| 2903 } | |
| 2904 | |
|
6917
e81fbc04a942
7191817: -XX:+UseSerialGC -XX:+UseLargePages crashes with SIGFPE on MacOS X
coleenp
parents:
6916
diff
changeset
|
2905 #ifndef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD. |
| 0 | 2906 FLAG_SET_DEFAULT(UseLargePages, true); |
|
6917
e81fbc04a942
7191817: -XX:+UseSerialGC -XX:+UseLargePages crashes with SIGFPE on MacOS X
coleenp
parents:
6916
diff
changeset
|
2907 #endif |
| 0 | 2908 |
| 2909 // Increase some data structure sizes for efficiency | |
| 2910 FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize); | |
| 2911 FLAG_SET_CMDLINE(bool, ResizeTLAB, false); | |
| 2912 FLAG_SET_CMDLINE(uintx, TLABSize, 256*K); | |
| 2913 | |
| 2914 // See the OldPLABSize comment below, but replace 'after promotion' | |
| 2915 // with 'after copying'. YoungPLABSize is the size of the survivor | |
| 2916 // space per-gc-thread buffers. The default is 4kw. | |
| 2917 FLAG_SET_CMDLINE(uintx, YoungPLABSize, 256*K); // Note: this is in words | |
| 2918 | |
| 2919 // OldPLABSize is the size of the buffers in the old gen that | |
| 2920 // UseParallelGC uses to promote live data that doesn't fit in the | |
| 2921 // survivor spaces. At any given time, there's one for each gc thread. | |
| 2922 // The default size is 1kw. These buffers are rarely used, since the | |
| 2923 // survivor spaces are usually big enough. For specjbb, however, there | |
| 2924 // are occasions when there's lots of live data in the young gen | |
| 2925 // and we end up promoting some of it. We don't have a definite | |
| 2926 // explanation for why bumping OldPLABSize helps, but the theory | |
| 2927 // is that a bigger PLAB results in retaining something like the | |
| 2928 // original allocation order after promotion, which improves mutator | |
| 2929 // locality. A minor effect may be that larger PLABs reduce the | |
| 2930 // number of PLAB allocation events during gc. The value of 8kw | |
| 2931 // was arrived at by experimenting with specjbb. | |
| 2932 FLAG_SET_CMDLINE(uintx, OldPLABSize, 8*K); // Note: this is in words | |
| 2933 | |
| 2934 // Enable parallel GC and adaptive generation sizing | |
| 2935 FLAG_SET_CMDLINE(bool, UseParallelGC, true); | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2936 FLAG_SET_DEFAULT(ParallelGCThreads, |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2937 Abstract_VM_Version::parallel_worker_threads()); |
| 0 | 2938 |
| 2939 // Encourage steady state memory management | |
| 2940 FLAG_SET_CMDLINE(uintx, ThresholdTolerance, 100); | |
| 2941 | |
| 2942 // This appears to improve mutator locality | |
| 2943 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); | |
| 2944 | |
| 2945 // Get around early Solaris scheduling bug | |
| 2946 // (affinity vs other jobs on system) | |
| 2947 // but disallow DR and offlining (5008695). | |
| 2948 FLAG_SET_CMDLINE(bool, BindGCTaskThreadsToCPUs, true); | |
| 2949 | |
| 2950 } else if (match_option(option, "-XX:+NeverTenure", &tail)) { | |
| 2951 // The last option must always win. | |
| 2952 FLAG_SET_CMDLINE(bool, AlwaysTenure, false); | |
| 2953 FLAG_SET_CMDLINE(bool, NeverTenure, true); | |
| 2954 } else if (match_option(option, "-XX:+AlwaysTenure", &tail)) { | |
| 2955 // The last option must always win. | |
| 2956 FLAG_SET_CMDLINE(bool, NeverTenure, false); | |
| 2957 FLAG_SET_CMDLINE(bool, AlwaysTenure, true); | |
| 2958 } else if (match_option(option, "-XX:+CMSPermGenSweepingEnabled", &tail) || | |
| 2959 match_option(option, "-XX:-CMSPermGenSweepingEnabled", &tail)) { | |
| 2960 jio_fprintf(defaultStream::error_stream(), | |
| 2961 "Please use CMSClassUnloadingEnabled in place of " | |
| 2962 "CMSPermGenSweepingEnabled in the future\n"); | |
| 2963 } else if (match_option(option, "-XX:+UseGCTimeLimit", &tail)) { | |
| 2964 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, true); | |
| 2965 jio_fprintf(defaultStream::error_stream(), | |
| 2966 "Please use -XX:+UseGCOverheadLimit in place of " | |
| 2967 "-XX:+UseGCTimeLimit in the future\n"); | |
| 2968 } else if (match_option(option, "-XX:-UseGCTimeLimit", &tail)) { | |
| 2969 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, false); | |
| 2970 jio_fprintf(defaultStream::error_stream(), | |
| 2971 "Please use -XX:-UseGCOverheadLimit in place of " | |
| 2972 "-XX:-UseGCTimeLimit in the future\n"); | |
| 2973 // The TLE options are for compatibility with 1.3 and will be | |
| 2974 // removed without notice in a future release. These options | |
| 2975 // are not to be documented. | |
| 2976 } else if (match_option(option, "-XX:MaxTLERatio=", &tail)) { | |
| 2977 // No longer used. | |
| 2978 } else if (match_option(option, "-XX:+ResizeTLE", &tail)) { | |
| 2979 FLAG_SET_CMDLINE(bool, ResizeTLAB, true); | |
| 2980 } else if (match_option(option, "-XX:-ResizeTLE", &tail)) { | |
| 2981 FLAG_SET_CMDLINE(bool, ResizeTLAB, false); | |
| 2982 } else if (match_option(option, "-XX:+PrintTLE", &tail)) { | |
| 2983 FLAG_SET_CMDLINE(bool, PrintTLAB, true); | |
| 2984 } else if (match_option(option, "-XX:-PrintTLE", &tail)) { | |
| 2985 FLAG_SET_CMDLINE(bool, PrintTLAB, false); | |
| 2986 } else if (match_option(option, "-XX:TLEFragmentationRatio=", &tail)) { | |
| 2987 // No longer used. | |
| 2988 } else if (match_option(option, "-XX:TLESize=", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2989 julong long_tlab_size = 0; |
| 0 | 2990 ArgsRange errcode = parse_memory_size(tail, &long_tlab_size, 1); |
| 2991 if (errcode != arg_in_range) { | |
| 2992 jio_fprintf(defaultStream::error_stream(), | |
| 2993 "Invalid TLAB size: %s\n", option->optionString); | |
| 2994 describe_range_error(errcode); | |
| 2995 return JNI_EINVAL; | |
| 2996 } | |
| 2997 FLAG_SET_CMDLINE(uintx, TLABSize, long_tlab_size); | |
| 2998 } else if (match_option(option, "-XX:TLEThreadRatio=", &tail)) { | |
| 2999 // No longer used. | |
| 3000 } else if (match_option(option, "-XX:+UseTLE", &tail)) { | |
| 3001 FLAG_SET_CMDLINE(bool, UseTLAB, true); | |
| 3002 } else if (match_option(option, "-XX:-UseTLE", &tail)) { | |
| 3003 FLAG_SET_CMDLINE(bool, UseTLAB, false); | |
| 3004 } else if (match_option(option, "-XX:+DisplayVMOutputToStderr", &tail)) { | |
| 3005 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, false); | |
| 3006 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, true); | |
| 3007 } else if (match_option(option, "-XX:+DisplayVMOutputToStdout", &tail)) { | |
| 3008 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, false); | |
| 3009 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, true); | |
| 3010 } else if (match_option(option, "-XX:+ExtendedDTraceProbes", &tail)) { | |
| 4006 | 3011 #if defined(DTRACE_ENABLED) |
| 0 | 3012 FLAG_SET_CMDLINE(bool, ExtendedDTraceProbes, true); |
| 3013 FLAG_SET_CMDLINE(bool, DTraceMethodProbes, true); | |
| 3014 FLAG_SET_CMDLINE(bool, DTraceAllocProbes, true); | |
| 3015 FLAG_SET_CMDLINE(bool, DTraceMonitorProbes, true); | |
| 4006 | 3016 #else // defined(DTRACE_ENABLED) |
| 0 | 3017 jio_fprintf(defaultStream::error_stream(), |
| 4006 | 3018 "ExtendedDTraceProbes flag is not applicable for this configuration\n"); |
| 0 | 3019 return JNI_EINVAL; |
| 4006 | 3020 #endif // defined(DTRACE_ENABLED) |
| 0 | 3021 #ifdef ASSERT |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3022 } else if (match_option(option, "-XX:+FullGCALot", &tail)) { |
| 0 | 3023 FLAG_SET_CMDLINE(bool, FullGCALot, true); |
| 3024 // disable scavenge before parallel mark-compact | |
| 3025 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); | |
| 3026 #endif | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3027 } else if (match_option(option, "-XX:CMSParPromoteBlocksToClaim=", &tail)) { |
| 0 | 3028 julong cms_blocks_to_claim = (julong)atol(tail); |
| 3029 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim); | |
| 3030 jio_fprintf(defaultStream::error_stream(), | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3031 "Please use -XX:OldPLABSize in place of " |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3032 "-XX:CMSParPromoteBlocksToClaim in the future\n"); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3033 } else if (match_option(option, "-XX:ParCMSPromoteBlocksToClaim=", &tail)) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3034 julong cms_blocks_to_claim = (julong)atol(tail); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3035 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3036 jio_fprintf(defaultStream::error_stream(), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3037 "Please use -XX:OldPLABSize in place of " |
| 0 | 3038 "-XX:ParCMSPromoteBlocksToClaim in the future\n"); |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3039 } else if (match_option(option, "-XX:ParallelGCOldGenAllocBufferSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
3040 julong old_plab_size = 0; |
| 0 | 3041 ArgsRange errcode = parse_memory_size(tail, &old_plab_size, 1); |
| 3042 if (errcode != arg_in_range) { | |
| 3043 jio_fprintf(defaultStream::error_stream(), | |
| 3044 "Invalid old PLAB size: %s\n", option->optionString); | |
| 3045 describe_range_error(errcode); | |
| 3046 return JNI_EINVAL; | |
| 3047 } | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
3048 FLAG_SET_CMDLINE(uintx, OldPLABSize, old_plab_size); |
| 0 | 3049 jio_fprintf(defaultStream::error_stream(), |
| 3050 "Please use -XX:OldPLABSize in place of " | |
| 3051 "-XX:ParallelGCOldGenAllocBufferSize in the future\n"); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3052 } else if (match_option(option, "-XX:ParallelGCToSpaceAllocBufferSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
3053 julong young_plab_size = 0; |
| 0 | 3054 ArgsRange errcode = parse_memory_size(tail, &young_plab_size, 1); |
| 3055 if (errcode != arg_in_range) { | |
| 3056 jio_fprintf(defaultStream::error_stream(), | |
| 3057 "Invalid young PLAB size: %s\n", option->optionString); | |
| 3058 describe_range_error(errcode); | |
| 3059 return JNI_EINVAL; | |
| 3060 } | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
3061 FLAG_SET_CMDLINE(uintx, YoungPLABSize, young_plab_size); |
| 0 | 3062 jio_fprintf(defaultStream::error_stream(), |
| 3063 "Please use -XX:YoungPLABSize in place of " | |
| 3064 "-XX:ParallelGCToSpaceAllocBufferSize in the future\n"); | |
| 1284 | 3065 } else if (match_option(option, "-XX:CMSMarkStackSize=", &tail) || |
| 3066 match_option(option, "-XX:G1MarkStackSize=", &tail)) { | |
| 3067 julong stack_size = 0; | |
| 3068 ArgsRange errcode = parse_memory_size(tail, &stack_size, 1); | |
| 3069 if (errcode != arg_in_range) { | |
| 3070 jio_fprintf(defaultStream::error_stream(), | |
| 3071 "Invalid mark stack size: %s\n", option->optionString); | |
| 3072 describe_range_error(errcode); | |
| 3073 return JNI_EINVAL; | |
| 3074 } | |
| 3075 FLAG_SET_CMDLINE(uintx, MarkStackSize, stack_size); | |
| 3076 } else if (match_option(option, "-XX:CMSMarkStackSizeMax=", &tail)) { | |
| 3077 julong max_stack_size = 0; | |
| 3078 ArgsRange errcode = parse_memory_size(tail, &max_stack_size, 1); | |
| 3079 if (errcode != arg_in_range) { | |
| 3080 jio_fprintf(defaultStream::error_stream(), | |
| 3081 "Invalid maximum mark stack size: %s\n", | |
| 3082 option->optionString); | |
| 3083 describe_range_error(errcode); | |
| 3084 return JNI_EINVAL; | |
| 3085 } | |
| 3086 FLAG_SET_CMDLINE(uintx, MarkStackSizeMax, max_stack_size); | |
| 3087 } else if (match_option(option, "-XX:ParallelMarkingThreads=", &tail) || | |
| 3088 match_option(option, "-XX:ParallelCMSThreads=", &tail)) { | |
| 3089 uintx conc_threads = 0; | |
| 3090 if (!parse_uintx(tail, &conc_threads, 1)) { | |
| 3091 jio_fprintf(defaultStream::error_stream(), | |
| 3092 "Invalid concurrent threads: %s\n", option->optionString); | |
| 3093 return JNI_EINVAL; | |
| 3094 } | |
| 3095 FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads); | |
|
6199
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3096 } else if (match_option(option, "-XX:MaxDirectMemorySize=", &tail)) { |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3097 julong max_direct_memory_size = 0; |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3098 ArgsRange errcode = parse_memory_size(tail, &max_direct_memory_size, 0); |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3099 if (errcode != arg_in_range) { |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3100 jio_fprintf(defaultStream::error_stream(), |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3101 "Invalid maximum direct memory size: %s\n", |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3102 option->optionString); |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3103 describe_range_error(errcode); |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3104 return JNI_EINVAL; |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3105 } |
|
3f1ab0c19c30
7179383: MaxDirectMemorySize argument parsing is broken for values >2G
dholmes
parents:
6198
diff
changeset
|
3106 FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size); |
|
6878
85916677fc22
7188233: UseVMInterruptibleIO flag deprecate for JDK8
coleenp
parents:
6857
diff
changeset
|
3107 } else if (match_option(option, "-XX:+UseVMInterruptibleIO", &tail)) { |
|
85916677fc22
7188233: UseVMInterruptibleIO flag deprecate for JDK8
coleenp
parents:
6857
diff
changeset
|
3108 // NOTE! In JDK 9, the UseVMInterruptibleIO flag will completely go |
|
85916677fc22
7188233: UseVMInterruptibleIO flag deprecate for JDK8
coleenp
parents:
6857
diff
changeset
|
3109 // away and will cause VM initialization failures! |
|
85916677fc22
7188233: UseVMInterruptibleIO flag deprecate for JDK8
coleenp
parents:
6857
diff
changeset
|
3110 warning("-XX:+UseVMInterruptibleIO is obsolete and will be removed in a future release."); |
|
85916677fc22
7188233: UseVMInterruptibleIO flag deprecate for JDK8
coleenp
parents:
6857
diff
changeset
|
3111 FLAG_SET_CMDLINE(bool, UseVMInterruptibleIO, true); |
|
8081
579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
jprovino
parents:
8002
diff
changeset
|
3112 #if !INCLUDE_MANAGEMENT |
|
579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
jprovino
parents:
8002
diff
changeset
|
3113 } else if (match_option(option, "-XX:+ManagementServer", &tail)) { |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3114 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3115 "ManagementServer is not supported in this VM.\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3116 return JNI_ERR; |
|
8081
579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
jprovino
parents:
8002
diff
changeset
|
3117 #endif // INCLUDE_MANAGEMENT |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3118 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx |
| 0 | 3119 // Skip -XX:Flags= since that case has already been handled |
| 3120 if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) { | |
| 3121 if (!process_argument(tail, args->ignoreUnrecognized, origin)) { | |
| 3122 return JNI_EINVAL; | |
| 3123 } | |
| 3124 } | |
| 3125 // Unknown option | |
| 3126 } else if (is_bad_option(option, args->ignoreUnrecognized)) { | |
| 3127 return JNI_ERR; | |
| 3128 } | |
| 3129 } | |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
3349
diff
changeset
|
3130 |
|
449
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
3131 // Change the default value for flags which have different default values |
|
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
3132 // when working with older JDKs. |
|
1679
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
3133 #ifdef LINUX |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
3134 if (JDK_Version::current().compare_major(6) <= 0 && |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
3135 FLAG_IS_DEFAULT(UseLinuxPosixThreadCPUClocks)) { |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
3136 FLAG_SET_DEFAULT(UseLinuxPosixThreadCPUClocks, false); |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
3137 } |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
3138 #endif // LINUX |
| 0 | 3139 return JNI_OK; |
| 3140 } | |
| 3141 | |
| 3142 jint Arguments::finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required) { | |
| 3143 // This must be done after all -D arguments have been processed. | |
| 3144 scp_p->expand_endorsed(); | |
| 3145 | |
| 3146 if (scp_assembly_required || scp_p->get_endorsed() != NULL) { | |
| 3147 // Assemble the bootclasspath elements into the final path. | |
| 3148 Arguments::set_sysclasspath(scp_p->combined_path()); | |
| 3149 } | |
| 3150 | |
| 3151 // This must be done after all arguments have been processed. | |
| 3152 // java_compiler() true means set to "NONE" or empty. | |
| 3153 if (java_compiler() && !xdebug_mode()) { | |
| 3154 // For backwards compatibility, we switch to interpreted mode if | |
| 3155 // -Djava.compiler="NONE" or "" is specified AND "-Xdebug" was | |
| 3156 // not specified. | |
| 3157 set_mode_flags(_int); | |
| 3158 } | |
| 3159 if (CompileThreshold == 0) { | |
| 3160 set_mode_flags(_int); | |
| 3161 } | |
| 3162 | |
|
10292
acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
tschatzl
parents:
10287
diff
changeset
|
3163 // eventually fix up InitialTenuringThreshold if only MaxTenuringThreshold is set |
|
acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
tschatzl
parents:
10287
diff
changeset
|
3164 if (FLAG_IS_DEFAULT(InitialTenuringThreshold) && (InitialTenuringThreshold > MaxTenuringThreshold)) { |
|
acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
tschatzl
parents:
10287
diff
changeset
|
3165 FLAG_SET_ERGO(uintx, InitialTenuringThreshold, MaxTenuringThreshold); |
|
acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
tschatzl
parents:
10287
diff
changeset
|
3166 } |
|
acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
tschatzl
parents:
10287
diff
changeset
|
3167 |
| 0 | 3168 #ifndef COMPILER2 |
| 3169 // Don't degrade server performance for footprint | |
| 3170 if (FLAG_IS_DEFAULT(UseLargePages) && | |
| 3171 MaxHeapSize < LargePageHeapSizeThreshold) { | |
| 3172 // No need for large granularity pages w/small heaps. | |
| 3173 // Note that large pages are enabled/disabled for both the | |
| 3174 // Java heap and the code cache. | |
| 3175 FLAG_SET_DEFAULT(UseLargePages, false); | |
| 3176 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
3177 |
| 0 | 3178 #else |
| 3179 if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) { | |
| 3180 FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1); | |
| 3181 } | |
| 3182 #endif | |
| 3183 | |
|
11999
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
3184 #ifndef TIERED |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
3185 // Tiered compilation is undefined. |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
3186 UNSUPPORTED_OPTION(TieredCompilation, "TieredCompilation"); |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
3187 #endif |
|
79a5283f4595
8021120: TieredCompilation can be enabled even if TIERED is undefined
iignatyev
parents:
11154
diff
changeset
|
3188 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3189 // If we are running in a headless jre, force java.awt.headless property |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3190 // to be true unless the property has already been set. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3191 // Also allow the OS environment variable JAVA_AWT_HEADLESS to set headless state. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3192 if (os::is_headless_jre()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3193 const char* headless = Arguments::get_property("java.awt.headless"); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3194 if (headless == NULL) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3195 char envbuffer[128]; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3196 if (!os::getenv("JAVA_AWT_HEADLESS", envbuffer, sizeof(envbuffer))) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3197 if (!add_property("java.awt.headless=true")) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3198 return JNI_ENOMEM; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3199 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3200 } else { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3201 char buffer[256]; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3202 strcpy(buffer, "java.awt.headless="); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3203 strcat(buffer, envbuffer); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3204 if (!add_property(buffer)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3205 return JNI_ENOMEM; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3206 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3207 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3208 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3209 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3210 |
| 0 | 3211 if (!check_vm_args_consistency()) { |
| 3212 return JNI_ERR; | |
| 3213 } | |
| 3214 | |
| 3215 return JNI_OK; | |
| 3216 } | |
| 3217 | |
| 3218 jint Arguments::parse_java_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p) { | |
| 3219 return parse_options_environment_variable("_JAVA_OPTIONS", scp_p, | |
| 3220 scp_assembly_required_p); | |
| 3221 } | |
| 3222 | |
| 3223 jint Arguments::parse_java_tool_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p) { | |
| 3224 return parse_options_environment_variable("JAVA_TOOL_OPTIONS", scp_p, | |
| 3225 scp_assembly_required_p); | |
| 3226 } | |
| 3227 | |
| 3228 jint Arguments::parse_options_environment_variable(const char* name, SysClassPath* scp_p, bool* scp_assembly_required_p) { | |
| 3229 const int N_MAX_OPTIONS = 64; | |
| 3230 const int OPTION_BUFFER_SIZE = 1024; | |
| 3231 char buffer[OPTION_BUFFER_SIZE]; | |
| 3232 | |
| 3233 // The variable will be ignored if it exceeds the length of the buffer. | |
| 3234 // Don't check this variable if user has special privileges | |
| 3235 // (e.g. unix su command). | |
| 3236 if (os::getenv(name, buffer, sizeof(buffer)) && | |
| 3237 !os::have_special_privileges()) { | |
| 3238 JavaVMOption options[N_MAX_OPTIONS]; // Construct option array | |
| 3239 jio_fprintf(defaultStream::error_stream(), | |
| 3240 "Picked up %s: %s\n", name, buffer); | |
| 3241 char* rd = buffer; // pointer to the input string (rd) | |
| 3242 int i; | |
| 3243 for (i = 0; i < N_MAX_OPTIONS;) { // repeat for all options in the input string | |
| 3244 while (isspace(*rd)) rd++; // skip whitespace | |
| 3245 if (*rd == 0) break; // we re done when the input string is read completely | |
| 3246 | |
| 3247 // The output, option string, overwrites the input string. | |
| 3248 // Because of quoting, the pointer to the option string (wrt) may lag the pointer to | |
| 3249 // input string (rd). | |
| 3250 char* wrt = rd; | |
| 3251 | |
| 3252 options[i++].optionString = wrt; // Fill in option | |
| 3253 while (*rd != 0 && !isspace(*rd)) { // unquoted strings terminate with a space or NULL | |
| 3254 if (*rd == '\'' || *rd == '"') { // handle a quoted string | |
| 3255 int quote = *rd; // matching quote to look for | |
| 3256 rd++; // don't copy open quote | |
| 3257 while (*rd != quote) { // include everything (even spaces) up until quote | |
| 3258 if (*rd == 0) { // string termination means unmatched string | |
| 3259 jio_fprintf(defaultStream::error_stream(), | |
| 3260 "Unmatched quote in %s\n", name); | |
| 3261 return JNI_ERR; | |
| 3262 } | |
| 3263 *wrt++ = *rd++; // copy to option string | |
| 3264 } | |
| 3265 rd++; // don't copy close quote | |
| 3266 } else { | |
| 3267 *wrt++ = *rd++; // copy to option string | |
| 3268 } | |
| 3269 } | |
| 3270 // Need to check if we're done before writing a NULL, | |
| 3271 // because the write could be to the byte that rd is pointing to. | |
| 3272 if (*rd++ == 0) { | |
| 3273 *wrt = 0; | |
| 3274 break; | |
| 3275 } | |
| 3276 *wrt = 0; // Zero terminate option | |
| 3277 } | |
| 3278 // Construct JavaVMInitArgs structure and parse as if it was part of the command line | |
| 3279 JavaVMInitArgs vm_args; | |
| 3280 vm_args.version = JNI_VERSION_1_2; | |
| 3281 vm_args.options = options; | |
| 3282 vm_args.nOptions = i; | |
| 564 | 3283 vm_args.ignoreUnrecognized = IgnoreUnrecognizedVMOptions; |
| 0 | 3284 |
| 3285 if (PrintVMOptions) { | |
| 3286 const char* tail; | |
| 3287 for (int i = 0; i < vm_args.nOptions; i++) { | |
| 3288 const JavaVMOption *option = vm_args.options + i; | |
| 3289 if (match_option(option, "-XX:", &tail)) { | |
| 3290 logOption(tail); | |
| 3291 } | |
| 3292 } | |
| 3293 } | |
| 3294 | |
| 3295 return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR)); | |
| 3296 } | |
| 3297 return JNI_OK; | |
| 3298 } | |
| 3299 | |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
3300 void Arguments::set_shared_spaces_flags() { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
3301 if (DumpSharedSpaces) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
3302 if (RequireSharedSpaces) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
3303 warning("cannot dump shared archive while using shared archive"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
3304 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
3305 UseSharedSpaces = false; |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3306 #ifdef _LP64 |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3307 if (!UseCompressedOops || !UseCompressedClassPointers) { |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3308 vm_exit_during_initialization( |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3309 "Cannot dump shared archive when UseCompressedOops or UseCompressedClassPointers is off.", NULL); |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3310 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3311 } else { |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3312 // UseCompressedOops and UseCompressedClassPointers must be on for UseSharedSpaces. |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3313 if (!UseCompressedOops || !UseCompressedClassPointers) { |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3314 no_shared_spaces(); |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3315 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12003
diff
changeset
|
3316 #endif |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6628
diff
changeset
|
3317 } |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
3318 } |
|
1891
9de67bf4244d
6996136: VM crash in src/share/vm/runtime/virtualspace.cpp:424
iveresov
parents:
1890
diff
changeset
|
3319 |
|
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8847
diff
changeset
|
3320 #if !INCLUDE_ALL_GCS |
|
8086
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3321 static void force_serial_gc() { |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3322 FLAG_SET_DEFAULT(UseSerialGC, true); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3323 FLAG_SET_DEFAULT(CMSIncrementalMode, false); // special CMS suboption |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3324 UNSUPPORTED_GC_OPTION(UseG1GC); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3325 UNSUPPORTED_GC_OPTION(UseParallelGC); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3326 UNSUPPORTED_GC_OPTION(UseParallelOldGC); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3327 UNSUPPORTED_GC_OPTION(UseConcMarkSweepGC); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3328 UNSUPPORTED_GC_OPTION(UseParNewGC); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3329 } |
|
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8847
diff
changeset
|
3330 #endif // INCLUDE_ALL_GCS |
|
8086
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3331 |
|
10270
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3332 // Sharing support |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3333 // Construct the path to the archive |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3334 static char* get_shared_archive_path() { |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3335 char *shared_archive_path; |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3336 if (SharedArchiveFile == NULL) { |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3337 char jvm_path[JVM_MAXPATHLEN]; |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3338 os::jvm_path(jvm_path, sizeof(jvm_path)); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3339 char *end = strrchr(jvm_path, *os::file_separator()); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3340 if (end != NULL) *end = '\0'; |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3341 size_t jvm_path_len = strlen(jvm_path); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3342 size_t file_sep_len = strlen(os::file_separator()); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3343 shared_archive_path = NEW_C_HEAP_ARRAY(char, jvm_path_len + |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3344 file_sep_len + 20, mtInternal); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3345 if (shared_archive_path != NULL) { |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3346 strncpy(shared_archive_path, jvm_path, jvm_path_len + 1); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3347 strncat(shared_archive_path, os::file_separator(), file_sep_len); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3348 strncat(shared_archive_path, "classes.jsa", 11); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3349 } |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3350 } else { |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3351 shared_archive_path = NEW_C_HEAP_ARRAY(char, strlen(SharedArchiveFile) + 1, mtInternal); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3352 if (shared_archive_path != NULL) { |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3353 strncpy(shared_archive_path, SharedArchiveFile, strlen(SharedArchiveFile) + 1); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3354 } |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3355 } |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3356 return shared_archive_path; |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3357 } |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3358 |
| 0 | 3359 // Parse entry point called from JNI_CreateJavaVM |
| 3360 | |
| 3361 jint Arguments::parse(const JavaVMInitArgs* args) { | |
| 3362 | |
| 3363 // Remaining part of option string | |
| 3364 const char* tail; | |
| 3365 | |
| 3366 // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed. | |
|
6196
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3367 const char* hotspotrc = ".hotspotrc"; |
| 0 | 3368 bool settings_file_specified = false; |
|
6196
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3369 bool needs_hotspotrc_warning = false; |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3370 |
| 564 | 3371 const char* flags_file; |
| 0 | 3372 int index; |
| 3373 for (index = 0; index < args->nOptions; index++) { | |
| 3374 const JavaVMOption *option = args->options + index; | |
| 3375 if (match_option(option, "-XX:Flags=", &tail)) { | |
| 564 | 3376 flags_file = tail; |
| 0 | 3377 settings_file_specified = true; |
| 3378 } | |
| 3379 if (match_option(option, "-XX:+PrintVMOptions", &tail)) { | |
| 3380 PrintVMOptions = true; | |
| 3381 } | |
|
253
b0fe4deeb9fb
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
196
diff
changeset
|
3382 if (match_option(option, "-XX:-PrintVMOptions", &tail)) { |
|
b0fe4deeb9fb
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
196
diff
changeset
|
3383 PrintVMOptions = false; |
|
b0fe4deeb9fb
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
196
diff
changeset
|
3384 } |
| 564 | 3385 if (match_option(option, "-XX:+IgnoreUnrecognizedVMOptions", &tail)) { |
| 3386 IgnoreUnrecognizedVMOptions = true; | |
| 3387 } | |
| 3388 if (match_option(option, "-XX:-IgnoreUnrecognizedVMOptions", &tail)) { | |
| 3389 IgnoreUnrecognizedVMOptions = false; | |
| 3390 } | |
| 1150 | 3391 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) { |
| 4773 | 3392 CommandLineFlags::printFlags(tty, false); |
| 1150 | 3393 vm_exit(0); |
| 3394 } | |
| 6197 | 3395 if (match_option(option, "-XX:NativeMemoryTracking", &tail)) { |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3396 #if INCLUDE_NMT |
| 6197 | 3397 MemTracker::init_tracking_options(tail); |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3398 #else |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3399 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3400 "Native Memory Tracking is not supported in this VM\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3401 return JNI_ERR; |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3402 #endif |
| 6197 | 3403 } |
| 3404 | |
|
1768
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
3405 |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
3406 #ifndef PRODUCT |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
3407 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) { |
| 4773 | 3408 CommandLineFlags::printFlags(tty, true); |
|
1768
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
3409 vm_exit(0); |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
3410 } |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
3411 #endif |
| 564 | 3412 } |
| 3413 | |
| 3414 if (IgnoreUnrecognizedVMOptions) { | |
| 3415 // uncast const to modify the flag args->ignoreUnrecognized | |
| 3416 *(jboolean*)(&args->ignoreUnrecognized) = true; | |
| 3417 } | |
| 3418 | |
| 3419 // Parse specified settings file | |
| 3420 if (settings_file_specified) { | |
| 3421 if (!process_settings_file(flags_file, true, args->ignoreUnrecognized)) { | |
| 3422 return JNI_EINVAL; | |
| 3423 } | |
|
6196
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3424 } else { |
|
6150
1e76463170b3
7110720: Issue with vm config file loadingIssue with vm config file loading
kamg
parents:
4780
diff
changeset
|
3425 #ifdef ASSERT |
|
6196
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3426 // Parse default .hotspotrc settings file |
| 0 | 3427 if (!process_settings_file(".hotspotrc", false, args->ignoreUnrecognized)) { |
| 3428 return JNI_EINVAL; | |
| 3429 } | |
|
6196
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3430 #else |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3431 struct stat buf; |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3432 if (os::stat(hotspotrc, &buf) == 0) { |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3433 needs_hotspotrc_warning = true; |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3434 } |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3435 #endif |
| 0 | 3436 } |
| 3437 | |
| 3438 if (PrintVMOptions) { | |
| 3439 for (index = 0; index < args->nOptions; index++) { | |
| 3440 const JavaVMOption *option = args->options + index; | |
| 3441 if (match_option(option, "-XX:", &tail)) { | |
| 3442 logOption(tail); | |
| 3443 } | |
| 3444 } | |
| 3445 } | |
| 3446 | |
| 3447 // Parse JavaVMInitArgs structure passed in, as well as JAVA_TOOL_OPTIONS and _JAVA_OPTIONS | |
| 3448 jint result = parse_vm_init_args(args); | |
| 3449 if (result != JNI_OK) { | |
| 3450 return result; | |
| 3451 } | |
| 3452 | |
|
10270
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3453 // Call get_shared_archive_path() here, after possible SharedArchiveFile option got parsed. |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3454 SharedArchivePath = get_shared_archive_path(); |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3455 if (SharedArchivePath == NULL) { |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3456 return JNI_ENOMEM; |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3457 } |
|
f944ba972151
8014138: Add VM option to facilitate the writing of CDS tests
hseigel
parents:
10264
diff
changeset
|
3458 |
|
6196
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3459 // Delay warning until here so that we've had a chance to process |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3460 // the -XX:-PrintWarnings flag |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3461 if (needs_hotspotrc_warning) { |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3462 warning("%s file is present but has been ignored. " |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3463 "Run with -XX:Flags=%s to load the file.", |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3464 hotspotrc, hotspotrc); |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3465 } |
|
3759236eea14
7167142: Consider a warning when finding a .hotspotrc or .hotspot_compiler file that isn't used
kamg
parents:
6158
diff
changeset
|
3466 |
|
6917
e81fbc04a942
7191817: -XX:+UseSerialGC -XX:+UseLargePages crashes with SIGFPE on MacOS X
coleenp
parents:
6916
diff
changeset
|
3467 #ifdef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD. |
|
e81fbc04a942
7191817: -XX:+UseSerialGC -XX:+UseLargePages crashes with SIGFPE on MacOS X
coleenp
parents:
6916
diff
changeset
|
3468 UNSUPPORTED_OPTION(UseLargePages, "-XX:+UseLargePages"); |
|
e81fbc04a942
7191817: -XX:+UseSerialGC -XX:+UseLargePages crashes with SIGFPE on MacOS X
coleenp
parents:
6916
diff
changeset
|
3469 #endif |
|
e81fbc04a942
7191817: -XX:+UseSerialGC -XX:+UseLargePages crashes with SIGFPE on MacOS X
coleenp
parents:
6916
diff
changeset
|
3470 |
|
8086
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3471 #if INCLUDE_ALL_GCS |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3472 #if (defined JAVASE_EMBEDDED || defined ARM) |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3473 UNSUPPORTED_OPTION(UseG1GC, "G1 GC"); |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3474 #endif |
|
1605eef8e11e
8003581: UseG1GC is not properly accounted for by INCLUDE_ALTERNATE_GCS
jprovino
parents:
8083
diff
changeset
|
3475 #endif |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3476 |
| 0 | 3477 #ifndef PRODUCT |
| 3478 if (TraceBytecodesAt != 0) { | |
| 3479 TraceBytecodes = true; | |
| 3480 } | |
| 3481 if (CountCompiledCalls) { | |
| 3482 if (UseCounterDecay) { | |
| 3483 warning("UseCounterDecay disabled because CountCalls is set"); | |
| 3484 UseCounterDecay = false; | |
| 3485 } | |
| 3486 } | |
| 3487 #endif // PRODUCT | |
| 3488 | |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3489 // JSR 292 is not supported before 1.7 |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3490 if (!JDK_Version::is_gte_jdk17x_version()) { |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3491 if (EnableInvokeDynamic) { |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3492 if (!FLAG_IS_DEFAULT(EnableInvokeDynamic)) { |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3493 warning("JSR 292 is not supported before 1.7. Disabling support."); |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3494 } |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3495 EnableInvokeDynamic = false; |
| 710 | 3496 } |
| 3497 } | |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3498 |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3499 if (EnableInvokeDynamic && ScavengeRootsInCode == 0) { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
3500 if (!FLAG_IS_DEFAULT(ScavengeRootsInCode)) { |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2378
diff
changeset
|
3501 warning("forcing ScavengeRootsInCode non-zero because EnableInvokeDynamic is true"); |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
3502 } |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
3503 ScavengeRootsInCode = 1; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
3504 } |
| 710 | 3505 |
| 0 | 3506 if (PrintGCDetails) { |
| 3507 // Turn on -verbose:gc options as well | |
| 3508 PrintGC = true; | |
| 3509 } | |
| 3510 | |
|
6064
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3511 if (!JDK_Version::is_gte_jdk18x_version()) { |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3512 // To avoid changing the log format for 7 updates this flag is only |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3513 // true by default in JDK8 and above. |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3514 if (FLAG_IS_DEFAULT(PrintGCCause)) { |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3515 FLAG_SET_DEFAULT(PrintGCCause, false); |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3516 } |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3517 } |
|
9d679effd28c
7166894: Add gc cause to GC logging for all collectors
brutisso
parents:
6017
diff
changeset
|
3518 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
3519 // Set object alignment values. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
3520 set_object_alignment(); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
3521 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3522 #if !INCLUDE_ALL_GCS |
| 1064 | 3523 force_serial_gc(); |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3524 #endif // INCLUDE_ALL_GCS |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3525 #if !INCLUDE_CDS |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3526 if (DumpSharedSpaces || RequireSharedSpaces) { |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3527 jio_fprintf(defaultStream::error_stream(), |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3528 "Shared spaces are not supported in this VM\n"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3529 return JNI_ERR; |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3530 } |
|
8724
69ffa4ac9e53
8009835: Only produce a warning when -Xshare:auto is explicitly requested
jprovino
parents:
8720
diff
changeset
|
3531 if ((UseSharedSpaces && FLAG_IS_CMDLINE(UseSharedSpaces)) || PrintSharedSpaces) { |
|
8720
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3532 warning("Shared spaces are not supported in this VM"); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3533 FLAG_SET_DEFAULT(UseSharedSpaces, false); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3534 FLAG_SET_DEFAULT(PrintSharedSpaces, false); |
|
fad90b102190
8008310: Some adjustments needed to minimal VM warnings and errors for unsupported command line options
jprovino
parents:
8105
diff
changeset
|
3535 } |
| 0 | 3536 no_shared_spaces(); |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3537 #endif // INCLUDE_CDS |
| 0 | 3538 |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
3539 return JNI_OK; |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
3540 } |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
3541 |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
3542 jint Arguments::apply_ergo() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
3543 |
| 0 | 3544 // Set flags based on ergonomics. |
| 3545 set_ergonomics_flags(); | |
| 3546 | |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
3547 set_shared_spaces_flags(); |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1131
diff
changeset
|
3548 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3549 // Check the GC selections again. |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3550 if (!check_gc_consistency()) { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3551 return JNI_EINVAL; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3552 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3553 |
| 1783 | 3554 if (TieredCompilation) { |
| 3555 set_tiered_flags(); | |
| 3556 } else { | |
| 3557 // Check if the policy is valid. Policies 0 and 1 are valid for non-tiered setup. | |
| 3558 if (CompilationPolicyChoice >= 2) { | |
| 3559 vm_exit_during_initialization( | |
| 3560 "Incompatible compilation policy selected", NULL); | |
| 3561 } | |
| 3562 } | |
| 3563 | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3564 // Set heap size based on available physical memory |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3565 set_heap_size(); |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
3566 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3567 #if INCLUDE_ALL_GCS |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3568 // Set per-collector flags |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3569 if (UseParallelGC || UseParallelOldGC) { |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3570 set_parallel_gc_flags(); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3571 } else if (UseConcMarkSweepGC) { // should be done before ParNew check below |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3572 set_cms_and_parnew_gc_flags(); |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3573 } else if (UseParNewGC) { // skipped if CMS is set above |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3574 set_parnew_gc_flags(); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3575 } else if (UseG1GC) { |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3576 set_g1_gc_flags(); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
3577 } |
|
7452
e0ab18eafbde
8003820: Deprecate untested and rarely used GC combinations
brutisso
parents:
7451
diff
changeset
|
3578 check_deprecated_gcs(); |
| 8734 | 3579 check_deprecated_gc_flags(); |
|
8845
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3580 if (AssumeMP && !UseSerialGC) { |
|
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3581 if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) { |
|
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3582 warning("If the number of processors is expected to increase from one, then" |
|
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3583 " you should configure the number of parallel GC threads appropriately" |
|
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3584 " using -XX:ParallelGCThreads=N"); |
|
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3585 } |
|
1b90c7607451
2178143: JVM crashes if the number of bound CPUs changed during runtime
minqi
parents:
8819
diff
changeset
|
3586 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3587 #else // INCLUDE_ALL_GCS |
| 0 | 3588 assert(verify_serial_gc_flags(), "SerialGC unset"); |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3589 #endif // INCLUDE_ALL_GCS |
| 0 | 3590 |
| 3591 // Set bytecode rewriting flags | |
| 3592 set_bytecode_flags(); | |
| 3593 | |
| 3594 // Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled. | |
| 3595 set_aggressive_opts_flags(); | |
| 3596 | |
|
2239
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3597 // Turn off biased locking for locking debug mode flags, |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3598 // which are subtlely different from each other but neither works with |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3599 // biased locking. |
| 2331 | 3600 if (UseHeavyMonitors |
| 3601 #ifdef COMPILER1 | |
| 3602 || !UseFastLocking | |
| 3603 #endif // COMPILER1 | |
| 3604 ) { | |
|
2239
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3605 if (!FLAG_IS_DEFAULT(UseBiasedLocking) && UseBiasedLocking) { |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3606 // flag set to true on command line; warn the user that they |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3607 // can't enable biased locking here |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3608 warning("Biased Locking is not supported with locking debug flags" |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3609 "; ignoring UseBiasedLocking flag." ); |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3610 } |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3611 UseBiasedLocking = false; |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3612 } |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3613 |
| 0 | 3614 #ifdef CC_INTERP |
| 1131 | 3615 // Clear flags not supported by the C++ interpreter |
| 3616 FLAG_SET_DEFAULT(ProfileInterpreter, false); | |
| 0 | 3617 FLAG_SET_DEFAULT(UseBiasedLocking, false); |
| 1131 | 3618 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false)); |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3619 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedClassPointers, false)); |
| 1131 | 3620 #endif // CC_INTERP |
| 3621 | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3622 #ifdef COMPILER2 |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3623 if (!UseBiasedLocking || EmitSync != 0) { |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3624 UseOptoBiasInlining = false; |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3625 } |
| 4777 | 3626 if (!EliminateLocks) { |
| 3627 EliminateNestedLocks = false; | |
| 3628 } | |
| 7473 | 3629 if (!Inline) { |
| 3630 IncrementalInline = false; | |
| 3631 } | |
| 3632 #ifndef PRODUCT | |
| 3633 if (!IncrementalInline) { | |
| 3634 AlwaysIncrementalInline = false; | |
| 3635 } | |
| 3636 #endif | |
| 3637 if (IncrementalInline && FLAG_IS_DEFAULT(MaxNodeLimit)) { | |
| 3638 // incremental inlining: bump MaxNodeLimit | |
| 3639 FLAG_SET_DEFAULT(MaxNodeLimit, (intx)75000); | |
| 3640 } | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3641 #endif |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3642 |
|
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3643 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) { |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3644 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output"); |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3645 DebugNonSafepoints = true; |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3646 } |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3647 |
|
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3648 if (FLAG_IS_CMDLINE(CompressedClassSpaceSize) && !UseCompressedClassPointers) { |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3649 warning("Setting CompressedClassSpaceSize has no effect when compressed class pointers are not used"); |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3650 } |
|
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12182
diff
changeset
|
3651 |
|
1188
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3652 #ifndef PRODUCT |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3653 if (CompileTheWorld) { |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3654 // Force NmethodSweeper to sweep whole CodeCache each time. |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3655 if (FLAG_IS_DEFAULT(NmethodSweepFraction)) { |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3656 NmethodSweepFraction = 1; |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3657 } |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3658 } |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3659 #endif |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3660 |
| 0 | 3661 if (PrintCommandLineFlags) { |
| 4773 | 3662 CommandLineFlags::printSetFlags(tty); |
| 0 | 3663 } |
| 3664 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3665 // Apply CPU specific policy for the BiasedLocking |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3666 if (UseBiasedLocking) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3667 if (!VM_Version::use_biased_locking() && |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3668 !(FLAG_IS_CMDLINE(UseBiasedLocking))) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3669 UseBiasedLocking = false; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3670 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3671 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3672 |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3673 // set PauseAtExit if the gamma launcher was used and a debugger is attached |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3674 // but only if not already set on the commandline |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3675 if (Arguments::created_by_gamma_launcher() && os::is_debugger_attached()) { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3676 bool set = false; |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3677 CommandLineFlags::wasSetOnCmdline("PauseAtExit", &set); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3678 if (!set) { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3679 FLAG_SET_DEFAULT(PauseAtExit, true); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3680 } |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3681 } |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3682 |
| 0 | 3683 return JNI_OK; |
| 3684 } | |
| 3685 | |
|
7177
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3686 jint Arguments::adjust_after_os() { |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3687 #if INCLUDE_ALL_GCS |
|
7177
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3688 if (UseParallelGC || UseParallelOldGC) { |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3689 if (UseNUMA) { |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3690 if (FLAG_IS_DEFAULT(MinHeapDeltaBytes)) { |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3691 FLAG_SET_DEFAULT(MinHeapDeltaBytes, 64*M); |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3692 } |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3693 // For those collectors or operating systems (eg, Windows) that do |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3694 // not support full UseNUMA, we will map to UseNUMAInterleaving for now |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3695 UseNUMAInterleaving = true; |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3696 } |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3697 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7479
diff
changeset
|
3698 #endif // INCLUDE_ALL_GCS |
|
7177
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3699 return JNI_OK; |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3700 } |
|
53715fb1597d
7198334: UseNUMA modifies system parameters on non-NUMA system
brutisso
parents:
6982
diff
changeset
|
3701 |
| 0 | 3702 int Arguments::PropertyList_count(SystemProperty* pl) { |
| 3703 int count = 0; | |
| 3704 while(pl != NULL) { | |
| 3705 count++; | |
| 3706 pl = pl->next(); | |
| 3707 } | |
| 3708 return count; | |
| 3709 } | |
| 3710 | |
| 3711 const char* Arguments::PropertyList_get_value(SystemProperty *pl, const char* key) { | |
| 3712 assert(key != NULL, "just checking"); | |
| 3713 SystemProperty* prop; | |
| 3714 for (prop = pl; prop != NULL; prop = prop->next()) { | |
| 3715 if (strcmp(key, prop->key()) == 0) return prop->value(); | |
| 3716 } | |
| 3717 return NULL; | |
| 3718 } | |
| 3719 | |
| 3720 const char* Arguments::PropertyList_get_key_at(SystemProperty *pl, int index) { | |
| 3721 int count = 0; | |
| 3722 const char* ret_val = NULL; | |
| 3723 | |
| 3724 while(pl != NULL) { | |
| 3725 if(count >= index) { | |
| 3726 ret_val = pl->key(); | |
| 3727 break; | |
| 3728 } | |
| 3729 count++; | |
| 3730 pl = pl->next(); | |
| 3731 } | |
| 3732 | |
| 3733 return ret_val; | |
| 3734 } | |
| 3735 | |
| 3736 char* Arguments::PropertyList_get_value_at(SystemProperty* pl, int index) { | |
| 3737 int count = 0; | |
| 3738 char* ret_val = NULL; | |
| 3739 | |
| 3740 while(pl != NULL) { | |
| 3741 if(count >= index) { | |
| 3742 ret_val = pl->value(); | |
| 3743 break; | |
| 3744 } | |
| 3745 count++; | |
| 3746 pl = pl->next(); | |
| 3747 } | |
| 3748 | |
| 3749 return ret_val; | |
| 3750 } | |
| 3751 | |
| 3752 void Arguments::PropertyList_add(SystemProperty** plist, SystemProperty *new_p) { | |
| 3753 SystemProperty* p = *plist; | |
| 3754 if (p == NULL) { | |
| 3755 *plist = new_p; | |
| 3756 } else { | |
| 3757 while (p->next() != NULL) { | |
| 3758 p = p->next(); | |
| 3759 } | |
| 3760 p->set_next(new_p); | |
| 3761 } | |
| 3762 } | |
| 3763 | |
| 3764 void Arguments::PropertyList_add(SystemProperty** plist, const char* k, char* v) { | |
| 3765 if (plist == NULL) | |
| 3766 return; | |
| 3767 | |
| 3768 SystemProperty* new_p = new SystemProperty(k, v, true); | |
| 3769 PropertyList_add(plist, new_p); | |
| 3770 } | |
| 3771 | |
| 3772 // This add maintains unique property key in the list. | |
| 691 | 3773 void Arguments::PropertyList_unique_add(SystemProperty** plist, const char* k, char* v, jboolean append) { |
| 0 | 3774 if (plist == NULL) |
| 3775 return; | |
| 3776 | |
| 3777 // If property key exist then update with new value. | |
| 3778 SystemProperty* prop; | |
| 3779 for (prop = *plist; prop != NULL; prop = prop->next()) { | |
| 3780 if (strcmp(k, prop->key()) == 0) { | |
| 691 | 3781 if (append) { |
| 3782 prop->append_value(v); | |
| 3783 } else { | |
| 3784 prop->set_value(v); | |
| 3785 } | |
| 0 | 3786 return; |
| 3787 } | |
| 3788 } | |
| 3789 | |
| 3790 PropertyList_add(plist, k, v); | |
| 3791 } | |
| 3792 | |
| 3793 // Copies src into buf, replacing "%%" with "%" and "%p" with pid | |
| 3794 // Returns true if all of the source pointed by src has been copied over to | |
| 3795 // the destination buffer pointed by buf. Otherwise, returns false. | |
| 3796 // Notes: | |
| 3797 // 1. If the length (buflen) of the destination buffer excluding the | |
| 3798 // NULL terminator character is not long enough for holding the expanded | |
| 3799 // pid characters, it also returns false instead of returning the partially | |
| 3800 // expanded one. | |
| 3801 // 2. The passed in "buflen" should be large enough to hold the null terminator. | |
| 3802 bool Arguments::copy_expand_pid(const char* src, size_t srclen, | |
| 3803 char* buf, size_t buflen) { | |
| 3804 const char* p = src; | |
| 3805 char* b = buf; | |
| 3806 const char* src_end = &src[srclen]; | |
| 3807 char* buf_end = &buf[buflen - 1]; | |
| 3808 | |
| 3809 while (p < src_end && b < buf_end) { | |
| 3810 if (*p == '%') { | |
| 3811 switch (*(++p)) { | |
| 3812 case '%': // "%%" ==> "%" | |
| 3813 *b++ = *p++; | |
| 3814 break; | |
| 3815 case 'p': { // "%p" ==> current process id | |
| 3816 // buf_end points to the character before the last character so | |
| 3817 // that we could write '\0' to the end of the buffer. | |
| 3818 size_t buf_sz = buf_end - b + 1; | |
| 3819 int ret = jio_snprintf(b, buf_sz, "%d", os::current_process_id()); | |
| 3820 | |
| 3821 // if jio_snprintf fails or the buffer is not long enough to hold | |
| 3822 // the expanded pid, returns false. | |
| 3823 if (ret < 0 || ret >= (int)buf_sz) { | |
| 3824 return false; | |
| 3825 } else { | |
| 3826 b += ret; | |
| 3827 assert(*b == '\0', "fail in copy_expand_pid"); | |
| 3828 if (p == src_end && b == buf_end + 1) { | |
| 3829 // reach the end of the buffer. | |
| 3830 return true; | |
| 3831 } | |
| 3832 } | |
| 3833 p++; | |
| 3834 break; | |
| 3835 } | |
| 3836 default : | |
| 3837 *b++ = '%'; | |
| 3838 } | |
| 3839 } else { | |
| 3840 *b++ = *p++; | |
| 3841 } | |
| 3842 } | |
| 3843 *b = '\0'; | |
| 3844 return (p == src_end); // return false if not all of the source was copied | |
| 3845 } |