Mercurial > hg > truffle
annotate src/share/vm/runtime/arguments.cpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
| author | ysr |
|---|---|
| date | Wed, 16 Mar 2011 10:37:08 -0700 |
| parents | 1fb790245268 |
| children | 048f98400b8e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2129
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2095
diff
changeset
|
2 * Copyright (c) 1997, 2011, 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" | |
| 27 #include "compiler/compilerOracle.hpp" | |
| 28 #include "memory/allocation.inline.hpp" | |
| 29 #include "memory/cardTableRS.hpp" | |
| 30 #include "memory/referenceProcessor.hpp" | |
| 31 #include "memory/universe.inline.hpp" | |
| 32 #include "oops/oop.inline.hpp" | |
| 33 #include "prims/jvmtiExport.hpp" | |
| 34 #include "runtime/arguments.hpp" | |
| 35 #include "runtime/globals_extension.hpp" | |
| 36 #include "runtime/java.hpp" | |
| 37 #include "services/management.hpp" | |
| 38 #include "utilities/defaultStream.hpp" | |
| 39 #include "utilities/taskqueue.hpp" | |
| 40 #ifdef TARGET_ARCH_x86 | |
| 41 # include "vm_version_x86.hpp" | |
| 42 #endif | |
| 43 #ifdef TARGET_ARCH_sparc | |
| 44 # include "vm_version_sparc.hpp" | |
| 45 #endif | |
| 46 #ifdef TARGET_ARCH_zero | |
| 47 # include "vm_version_zero.hpp" | |
| 48 #endif | |
| 49 #ifdef TARGET_OS_FAMILY_linux | |
| 50 # include "os_linux.inline.hpp" | |
| 51 #endif | |
| 52 #ifdef TARGET_OS_FAMILY_solaris | |
| 53 # include "os_solaris.inline.hpp" | |
| 54 #endif | |
| 55 #ifdef TARGET_OS_FAMILY_windows | |
| 56 # include "os_windows.inline.hpp" | |
| 57 #endif | |
| 58 #ifndef SERIALGC | |
| 59 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp" | |
| 60 #endif | |
| 0 | 61 |
| 62 #define DEFAULT_VENDOR_URL_BUG "http://java.sun.com/webapps/bugreport/crash.jsp" | |
| 63 #define DEFAULT_JAVA_LAUNCHER "generic" | |
| 64 | |
| 65 char** Arguments::_jvm_flags_array = NULL; | |
| 66 int Arguments::_num_jvm_flags = 0; | |
| 67 char** Arguments::_jvm_args_array = NULL; | |
| 68 int Arguments::_num_jvm_args = 0; | |
| 69 char* Arguments::_java_command = NULL; | |
| 70 SystemProperty* Arguments::_system_properties = NULL; | |
| 71 const char* Arguments::_gc_log_filename = NULL; | |
| 72 bool Arguments::_has_profile = false; | |
| 73 bool Arguments::_has_alloc_profile = false; | |
| 74 uintx Arguments::_min_heap_size = 0; | |
| 75 Arguments::Mode Arguments::_mode = _mixed; | |
| 76 bool Arguments::_java_compiler = false; | |
| 77 bool Arguments::_xdebug_mode = false; | |
| 78 const char* Arguments::_java_vendor_url_bug = DEFAULT_VENDOR_URL_BUG; | |
| 79 const char* Arguments::_sun_java_launcher = DEFAULT_JAVA_LAUNCHER; | |
| 80 int Arguments::_sun_java_launcher_pid = -1; | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
81 bool Arguments::_created_by_gamma_launcher = false; |
| 0 | 82 |
| 83 // These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*) | |
| 84 bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods; | |
| 85 bool Arguments::_UseOnStackReplacement = UseOnStackReplacement; | |
| 86 bool Arguments::_BackgroundCompilation = BackgroundCompilation; | |
| 87 bool Arguments::_ClipInlining = ClipInlining; | |
| 88 | |
| 89 char* Arguments::SharedArchivePath = NULL; | |
| 90 | |
| 91 AgentLibraryList Arguments::_libraryList; | |
| 92 AgentLibraryList Arguments::_agentList; | |
| 93 | |
| 94 abort_hook_t Arguments::_abort_hook = NULL; | |
| 95 exit_hook_t Arguments::_exit_hook = NULL; | |
| 96 vfprintf_hook_t Arguments::_vfprintf_hook = NULL; | |
| 97 | |
| 98 | |
| 99 SystemProperty *Arguments::_java_ext_dirs = NULL; | |
| 100 SystemProperty *Arguments::_java_endorsed_dirs = NULL; | |
| 101 SystemProperty *Arguments::_sun_boot_library_path = NULL; | |
| 102 SystemProperty *Arguments::_java_library_path = NULL; | |
| 103 SystemProperty *Arguments::_java_home = NULL; | |
| 104 SystemProperty *Arguments::_java_class_path = NULL; | |
| 105 SystemProperty *Arguments::_sun_boot_class_path = NULL; | |
| 106 | |
| 107 char* Arguments::_meta_index_path = NULL; | |
| 108 char* Arguments::_meta_index_dir = NULL; | |
| 109 | |
| 110 static bool force_client_mode = false; | |
| 111 | |
| 112 // Check if head of 'option' matches 'name', and sets 'tail' remaining part of option string | |
| 113 | |
| 114 static bool match_option(const JavaVMOption *option, const char* name, | |
| 115 const char** tail) { | |
| 116 int len = (int)strlen(name); | |
| 117 if (strncmp(option->optionString, name, len) == 0) { | |
| 118 *tail = option->optionString + len; | |
| 119 return true; | |
| 120 } else { | |
| 121 return false; | |
| 122 } | |
| 123 } | |
| 124 | |
| 125 static void logOption(const char* opt) { | |
| 126 if (PrintVMOptions) { | |
| 127 jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt); | |
| 128 } | |
| 129 } | |
| 130 | |
| 131 // Process java launcher properties. | |
| 132 void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) { | |
| 133 // See if sun.java.launcher or sun.java.launcher.pid is defined. | |
| 134 // Must do this before setting up other system properties, | |
| 135 // as some of them may depend on launcher type. | |
| 136 for (int index = 0; index < args->nOptions; index++) { | |
| 137 const JavaVMOption* option = args->options + index; | |
| 138 const char* tail; | |
| 139 | |
| 140 if (match_option(option, "-Dsun.java.launcher=", &tail)) { | |
| 141 process_java_launcher_argument(tail, option->extraInfo); | |
| 142 continue; | |
| 143 } | |
| 144 if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) { | |
| 145 _sun_java_launcher_pid = atoi(tail); | |
| 146 continue; | |
| 147 } | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 // Initialize system properties key and value. | |
| 152 void Arguments::init_system_properties() { | |
| 153 | |
| 154 PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name", | |
| 155 "Java Virtual Machine Specification", false)); | |
| 156 PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(), false)); | |
| 157 PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(), false)); | |
| 158 PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(), true)); | |
| 159 | |
| 160 // following are JVMTI agent writeable properties. | |
| 161 // Properties values are set to NULL and they are | |
| 162 // os specific they are initialized in os::init_system_properties_values(). | |
| 163 _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL, true); | |
| 164 _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL, true); | |
| 165 _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL, true); | |
| 166 _java_library_path = new SystemProperty("java.library.path", NULL, true); | |
| 167 _java_home = new SystemProperty("java.home", NULL, true); | |
| 168 _sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL, true); | |
| 169 | |
| 170 _java_class_path = new SystemProperty("java.class.path", "", true); | |
| 171 | |
| 172 // Add to System Property list. | |
| 173 PropertyList_add(&_system_properties, _java_ext_dirs); | |
| 174 PropertyList_add(&_system_properties, _java_endorsed_dirs); | |
| 175 PropertyList_add(&_system_properties, _sun_boot_library_path); | |
| 176 PropertyList_add(&_system_properties, _java_library_path); | |
| 177 PropertyList_add(&_system_properties, _java_home); | |
| 178 PropertyList_add(&_system_properties, _java_class_path); | |
| 179 PropertyList_add(&_system_properties, _sun_boot_class_path); | |
| 180 | |
| 181 // Set OS specific system properties values | |
| 182 os::init_system_properties_values(); | |
| 183 } | |
| 184 | |
|
1864
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
185 |
|
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
186 // Update/Initialize System properties after JDK version number is known |
|
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
187 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
|
188 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
|
189 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
|
190 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
|
191 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
|
192 |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
193 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
|
194 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
|
195 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
|
196 } |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
197 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
|
198 |
|
35f885165c69
6981737: The java.vm.specification.version property is 1.0, seems like it should be 2.0
kamg
parents:
1875
diff
changeset
|
199 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
|
200 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
|
201 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
|
202 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
|
203 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
|
204 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
|
205 } |
|
dfb38ea7da17
6988363: Rebrand vm vendor property settings (jdk7 only)
zgu
parents:
1805
diff
changeset
|
206 |
| 242 | 207 /** |
| 208 * Provide a slightly more user-friendly way of eliminating -XX flags. | |
| 209 * When a flag is eliminated, it can be added to this list in order to | |
| 210 * continue accepting this flag on the command-line, while issuing a warning | |
| 211 * and ignoring the value. Once the JDK version reaches the 'accept_until' | |
| 212 * limit, we flatly refuse to admit the existence of the flag. This allows | |
| 213 * a flag to die correctly over JDK releases using HSX. | |
| 214 */ | |
| 215 typedef struct { | |
| 216 const char* name; | |
| 217 JDK_Version obsoleted_in; // when the flag went away | |
| 218 JDK_Version accept_until; // which version to start denying the existence | |
| 219 } ObsoleteFlag; | |
| 0 | 220 |
| 242 | 221 static ObsoleteFlag obsolete_jvm_flags[] = { |
| 222 { "UseTrainGC", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 223 { "UseSpecialLargeObjectHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 224 { "UseOversizedCarHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 225 { "TraceCarAllocation", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 226 { "PrintTrainGCProcessingStats", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 227 { "LogOfCarSpaceSize", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 228 { "OversizedCarThreshold", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 229 { "MinTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 230 { "DefaultTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 231 { "MaxTickInterval", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 232 { "DelayTickAdjustment", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 233 { "ProcessingToTenuringRatio", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 234 { "MinTrainLength", JDK_Version::jdk(5), JDK_Version::jdk(7) }, | |
| 235 { "AppendRatio", JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) }, | |
| 1064 | 236 { "DefaultMaxRAM", JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) }, |
| 237 { "DefaultInitialRAMFraction", | |
| 238 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
|
239 { "UseDepthFirstScavengeOrder", |
|
9d7a8ab3736b
6962589: remove breadth first scanning code from parallel gc
tonyp
parents:
1628
diff
changeset
|
240 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
|
241 { "HandlePromotionFailure", |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1832
diff
changeset
|
242 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
|
243 { "MaxLiveObjectEvacuationRatio", |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1832
diff
changeset
|
244 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
|
245 { "ForceSharedSpaces", JDK_Version::jdk_update(6,25), JDK_Version::jdk(8) }, |
| 242 | 246 { NULL, JDK_Version(0), JDK_Version(0) } |
| 247 }; | |
| 248 | |
| 249 // Returns true if the flag is obsolete and fits into the range specified | |
| 250 // for being ignored. In the case that the flag is ignored, the 'version' | |
| 251 // value is filled in with the version number when the flag became | |
| 252 // obsolete so that that value can be displayed to the user. | |
| 253 bool Arguments::is_newly_obsolete(const char *s, JDK_Version* version) { | |
| 0 | 254 int i = 0; |
| 242 | 255 assert(version != NULL, "Must provide a version buffer"); |
| 256 while (obsolete_jvm_flags[i].name != NULL) { | |
| 257 const ObsoleteFlag& flag_status = obsolete_jvm_flags[i]; | |
| 0 | 258 // <flag>=xxx form |
| 259 // [-|+]<flag> form | |
| 242 | 260 if ((strncmp(flag_status.name, s, strlen(flag_status.name)) == 0) || |
| 0 | 261 ((s[0] == '+' || s[0] == '-') && |
| 242 | 262 (strncmp(flag_status.name, &s[1], strlen(flag_status.name)) == 0))) { |
| 263 if (JDK_Version::current().compare(flag_status.accept_until) == -1) { | |
| 264 *version = flag_status.obsoleted_in; | |
| 265 return true; | |
| 266 } | |
| 0 | 267 } |
| 268 i++; | |
| 269 } | |
| 270 return false; | |
| 271 } | |
| 272 | |
| 273 // Constructs the system class path (aka boot class path) from the following | |
| 274 // components, in order: | |
| 275 // | |
| 276 // prefix // from -Xbootclasspath/p:... | |
| 277 // endorsed // the expansion of -Djava.endorsed.dirs=... | |
| 278 // base // from os::get_system_properties() or -Xbootclasspath= | |
| 279 // suffix // from -Xbootclasspath/a:... | |
| 280 // | |
| 281 // java.endorsed.dirs is a list of directories; any jar or zip files in the | |
| 282 // directories are added to the sysclasspath just before the base. | |
| 283 // | |
| 284 // This could be AllStatic, but it isn't needed after argument processing is | |
| 285 // complete. | |
| 286 class SysClassPath: public StackObj { | |
| 287 public: | |
| 288 SysClassPath(const char* base); | |
| 289 ~SysClassPath(); | |
| 290 | |
| 291 inline void set_base(const char* base); | |
| 292 inline void add_prefix(const char* prefix); | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
293 inline void add_suffix_to_prefix(const char* suffix); |
| 0 | 294 inline void add_suffix(const char* suffix); |
| 295 inline void reset_path(const char* base); | |
| 296 | |
| 297 // Expand the jar/zip files in each directory listed by the java.endorsed.dirs | |
| 298 // property. Must be called after all command-line arguments have been | |
| 299 // processed (in particular, -Djava.endorsed.dirs=...) and before calling | |
| 300 // combined_path(). | |
| 301 void expand_endorsed(); | |
| 302 | |
| 303 inline const char* get_base() const { return _items[_scp_base]; } | |
| 304 inline const char* get_prefix() const { return _items[_scp_prefix]; } | |
| 305 inline const char* get_suffix() const { return _items[_scp_suffix]; } | |
| 306 inline const char* get_endorsed() const { return _items[_scp_endorsed]; } | |
| 307 | |
| 308 // Combine all the components into a single c-heap-allocated string; caller | |
| 309 // must free the string if/when no longer needed. | |
| 310 char* combined_path(); | |
| 311 | |
| 312 private: | |
| 313 // Utility routines. | |
| 314 static char* add_to_path(const char* path, const char* str, bool prepend); | |
| 315 static char* add_jars_to_path(char* path, const char* directory); | |
| 316 | |
| 317 inline void reset_item_at(int index); | |
| 318 | |
| 319 // Array indices for the items that make up the sysclasspath. All except the | |
| 320 // base are allocated in the C heap and freed by this class. | |
| 321 enum { | |
| 322 _scp_prefix, // from -Xbootclasspath/p:... | |
| 323 _scp_endorsed, // the expansion of -Djava.endorsed.dirs=... | |
| 324 _scp_base, // the default sysclasspath | |
| 325 _scp_suffix, // from -Xbootclasspath/a:... | |
| 326 _scp_nitems // the number of items, must be last. | |
| 327 }; | |
| 328 | |
| 329 const char* _items[_scp_nitems]; | |
| 330 DEBUG_ONLY(bool _expansion_done;) | |
| 331 }; | |
| 332 | |
| 333 SysClassPath::SysClassPath(const char* base) { | |
| 334 memset(_items, 0, sizeof(_items)); | |
| 335 _items[_scp_base] = base; | |
| 336 DEBUG_ONLY(_expansion_done = false;) | |
| 337 } | |
| 338 | |
| 339 SysClassPath::~SysClassPath() { | |
| 340 // Free everything except the base. | |
| 341 for (int i = 0; i < _scp_nitems; ++i) { | |
| 342 if (i != _scp_base) reset_item_at(i); | |
| 343 } | |
| 344 DEBUG_ONLY(_expansion_done = false;) | |
| 345 } | |
| 346 | |
| 347 inline void SysClassPath::set_base(const char* base) { | |
| 348 _items[_scp_base] = base; | |
| 349 } | |
| 350 | |
| 351 inline void SysClassPath::add_prefix(const char* prefix) { | |
| 352 _items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true); | |
| 353 } | |
| 354 | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
355 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
|
356 _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
|
357 } |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
358 |
| 0 | 359 inline void SysClassPath::add_suffix(const char* suffix) { |
| 360 _items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false); | |
| 361 } | |
| 362 | |
| 363 inline void SysClassPath::reset_item_at(int index) { | |
| 364 assert(index < _scp_nitems && index != _scp_base, "just checking"); | |
| 365 if (_items[index] != NULL) { | |
| 366 FREE_C_HEAP_ARRAY(char, _items[index]); | |
| 367 _items[index] = NULL; | |
| 368 } | |
| 369 } | |
| 370 | |
| 371 inline void SysClassPath::reset_path(const char* base) { | |
| 372 // Clear the prefix and suffix. | |
| 373 reset_item_at(_scp_prefix); | |
| 374 reset_item_at(_scp_suffix); | |
| 375 set_base(base); | |
| 376 } | |
| 377 | |
| 378 //------------------------------------------------------------------------------ | |
| 379 | |
| 380 void SysClassPath::expand_endorsed() { | |
| 381 assert(_items[_scp_endorsed] == NULL, "can only be called once."); | |
| 382 | |
| 383 const char* path = Arguments::get_property("java.endorsed.dirs"); | |
| 384 if (path == NULL) { | |
| 385 path = Arguments::get_endorsed_dir(); | |
| 386 assert(path != NULL, "no default for java.endorsed.dirs"); | |
| 387 } | |
| 388 | |
| 389 char* expanded_path = NULL; | |
| 390 const char separator = *os::path_separator(); | |
| 391 const char* const end = path + strlen(path); | |
| 392 while (path < end) { | |
| 393 const char* tmp_end = strchr(path, separator); | |
| 394 if (tmp_end == NULL) { | |
| 395 expanded_path = add_jars_to_path(expanded_path, path); | |
| 396 path = end; | |
| 397 } else { | |
| 398 char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1); | |
| 399 memcpy(dirpath, path, tmp_end - path); | |
| 400 dirpath[tmp_end - path] = '\0'; | |
| 401 expanded_path = add_jars_to_path(expanded_path, dirpath); | |
| 402 FREE_C_HEAP_ARRAY(char, dirpath); | |
| 403 path = tmp_end + 1; | |
| 404 } | |
| 405 } | |
| 406 _items[_scp_endorsed] = expanded_path; | |
| 407 DEBUG_ONLY(_expansion_done = true;) | |
| 408 } | |
| 409 | |
| 410 // Combine the bootclasspath elements, some of which may be null, into a single | |
| 411 // c-heap-allocated string. | |
| 412 char* SysClassPath::combined_path() { | |
| 413 assert(_items[_scp_base] != NULL, "empty default sysclasspath"); | |
| 414 assert(_expansion_done, "must call expand_endorsed() first."); | |
| 415 | |
| 416 size_t lengths[_scp_nitems]; | |
| 417 size_t total_len = 0; | |
| 418 | |
| 419 const char separator = *os::path_separator(); | |
| 420 | |
| 421 // Get the lengths. | |
| 422 int i; | |
| 423 for (i = 0; i < _scp_nitems; ++i) { | |
| 424 if (_items[i] != NULL) { | |
| 425 lengths[i] = strlen(_items[i]); | |
| 426 // Include space for the separator char (or a NULL for the last item). | |
| 427 total_len += lengths[i] + 1; | |
| 428 } | |
| 429 } | |
| 430 assert(total_len > 0, "empty sysclasspath not allowed"); | |
| 431 | |
| 432 // Copy the _items to a single string. | |
| 433 char* cp = NEW_C_HEAP_ARRAY(char, total_len); | |
| 434 char* cp_tmp = cp; | |
| 435 for (i = 0; i < _scp_nitems; ++i) { | |
| 436 if (_items[i] != NULL) { | |
| 437 memcpy(cp_tmp, _items[i], lengths[i]); | |
| 438 cp_tmp += lengths[i]; | |
| 439 *cp_tmp++ = separator; | |
| 440 } | |
| 441 } | |
| 442 *--cp_tmp = '\0'; // Replace the extra separator. | |
| 443 return cp; | |
| 444 } | |
| 445 | |
| 446 // Note: path must be c-heap-allocated (or NULL); it is freed if non-null. | |
| 447 char* | |
| 448 SysClassPath::add_to_path(const char* path, const char* str, bool prepend) { | |
| 449 char *cp; | |
| 450 | |
| 451 assert(str != NULL, "just checking"); | |
| 452 if (path == NULL) { | |
| 453 size_t len = strlen(str) + 1; | |
| 454 cp = NEW_C_HEAP_ARRAY(char, len); | |
| 455 memcpy(cp, str, len); // copy the trailing null | |
| 456 } else { | |
| 457 const char separator = *os::path_separator(); | |
| 458 size_t old_len = strlen(path); | |
| 459 size_t str_len = strlen(str); | |
| 460 size_t len = old_len + str_len + 2; | |
| 461 | |
| 462 if (prepend) { | |
| 463 cp = NEW_C_HEAP_ARRAY(char, len); | |
| 464 char* cp_tmp = cp; | |
| 465 memcpy(cp_tmp, str, str_len); | |
| 466 cp_tmp += str_len; | |
| 467 *cp_tmp = separator; | |
| 468 memcpy(++cp_tmp, path, old_len + 1); // copy the trailing null | |
| 469 FREE_C_HEAP_ARRAY(char, path); | |
| 470 } else { | |
| 471 cp = REALLOC_C_HEAP_ARRAY(char, path, len); | |
| 472 char* cp_tmp = cp + old_len; | |
| 473 *cp_tmp = separator; | |
| 474 memcpy(++cp_tmp, str, str_len + 1); // copy the trailing null | |
| 475 } | |
| 476 } | |
| 477 return cp; | |
| 478 } | |
| 479 | |
| 480 // Scan the directory and append any jar or zip files found to path. | |
| 481 // Note: path must be c-heap-allocated (or NULL); it is freed if non-null. | |
| 482 char* SysClassPath::add_jars_to_path(char* path, const char* directory) { | |
| 483 DIR* dir = os::opendir(directory); | |
| 484 if (dir == NULL) return path; | |
| 485 | |
| 486 char dir_sep[2] = { '\0', '\0' }; | |
| 487 size_t directory_len = strlen(directory); | |
| 488 const char fileSep = *os::file_separator(); | |
| 489 if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep; | |
| 490 | |
| 491 /* Scan the directory for jars/zips, appending them to path. */ | |
| 492 struct dirent *entry; | |
| 493 char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory)); | |
| 494 while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) { | |
| 495 const char* name = entry->d_name; | |
| 496 const char* ext = name + strlen(name) - 4; | |
| 497 bool isJarOrZip = ext > name && | |
| 498 (os::file_name_strcmp(ext, ".jar") == 0 || | |
| 499 os::file_name_strcmp(ext, ".zip") == 0); | |
| 500 if (isJarOrZip) { | |
| 501 char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name)); | |
| 502 sprintf(jarpath, "%s%s%s", directory, dir_sep, name); | |
| 503 path = add_to_path(path, jarpath, false); | |
| 504 FREE_C_HEAP_ARRAY(char, jarpath); | |
| 505 } | |
| 506 } | |
| 507 FREE_C_HEAP_ARRAY(char, dbuf); | |
| 508 os::closedir(dir); | |
| 509 return path; | |
| 510 } | |
| 511 | |
| 512 // Parses a memory size specification string. | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
513 static bool atomull(const char *s, julong* result) { |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
514 julong n = 0; |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
515 int args_read = sscanf(s, os::julong_format_specifier(), &n); |
| 0 | 516 if (args_read != 1) { |
| 517 return false; | |
| 518 } | |
| 519 while (*s != '\0' && isdigit(*s)) { | |
| 520 s++; | |
| 521 } | |
| 522 // 4705540: illegal if more characters are found after the first non-digit | |
| 523 if (strlen(s) > 1) { | |
| 524 return false; | |
| 525 } | |
| 526 switch (*s) { | |
| 527 case 'T': case 't': | |
| 528 *result = n * G * K; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
529 // Check for overflow. |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
530 if (*result/((julong)G * K) != n) return false; |
| 0 | 531 return true; |
| 532 case 'G': case 'g': | |
| 533 *result = n * G; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
534 if (*result/G != n) return false; |
| 0 | 535 return true; |
| 536 case 'M': case 'm': | |
| 537 *result = n * M; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
538 if (*result/M != n) return false; |
| 0 | 539 return true; |
| 540 case 'K': case 'k': | |
| 541 *result = n * K; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
542 if (*result/K != n) return false; |
| 0 | 543 return true; |
| 544 case '\0': | |
| 545 *result = n; | |
| 546 return true; | |
| 547 default: | |
| 548 return false; | |
| 549 } | |
| 550 } | |
| 551 | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
552 Arguments::ArgsRange Arguments::check_memory_size(julong size, julong min_size) { |
| 0 | 553 if (size < min_size) return arg_too_small; |
| 554 // 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
|
555 if (size > max_uintx) return arg_too_big; |
| 0 | 556 return arg_in_range; |
| 557 } | |
| 558 | |
| 559 // Describe an argument out of range error | |
| 560 void Arguments::describe_range_error(ArgsRange errcode) { | |
| 561 switch(errcode) { | |
| 562 case arg_too_big: | |
| 563 jio_fprintf(defaultStream::error_stream(), | |
| 564 "The specified size exceeds the maximum " | |
| 565 "representable size.\n"); | |
| 566 break; | |
| 567 case arg_too_small: | |
| 568 case arg_unreadable: | |
| 569 case arg_in_range: | |
| 570 // do nothing for now | |
| 571 break; | |
| 572 default: | |
| 573 ShouldNotReachHere(); | |
| 574 } | |
| 575 } | |
| 576 | |
| 577 static bool set_bool_flag(char* name, bool value, FlagValueOrigin origin) { | |
| 578 return CommandLineFlags::boolAtPut(name, &value, origin); | |
| 579 } | |
| 580 | |
| 581 static bool set_fp_numeric_flag(char* name, char* value, FlagValueOrigin origin) { | |
| 582 double v; | |
| 583 if (sscanf(value, "%lf", &v) != 1) { | |
| 584 return false; | |
| 585 } | |
| 586 | |
| 587 if (CommandLineFlags::doubleAtPut(name, &v, origin)) { | |
| 588 return true; | |
| 589 } | |
| 590 return false; | |
| 591 } | |
| 592 | |
| 593 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
|
594 julong v; |
| 0 | 595 intx intx_v; |
| 596 bool is_neg = false; | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
597 // Check the sign first since atomull() parses only unsigned values. |
| 0 | 598 if (*value == '-') { |
| 599 if (!CommandLineFlags::intxAt(name, &intx_v)) { | |
| 600 return false; | |
| 601 } | |
| 602 value++; | |
| 603 is_neg = true; | |
| 604 } | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
605 if (!atomull(value, &v)) { |
| 0 | 606 return false; |
| 607 } | |
| 608 intx_v = (intx) v; | |
| 609 if (is_neg) { | |
| 610 intx_v = -intx_v; | |
| 611 } | |
| 612 if (CommandLineFlags::intxAtPut(name, &intx_v, origin)) { | |
| 613 return true; | |
| 614 } | |
| 615 uintx uintx_v = (uintx) v; | |
| 616 if (!is_neg && CommandLineFlags::uintxAtPut(name, &uintx_v, origin)) { | |
| 617 return true; | |
| 618 } | |
| 1064 | 619 uint64_t uint64_t_v = (uint64_t) v; |
| 620 if (!is_neg && CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin)) { | |
| 621 return true; | |
| 622 } | |
| 0 | 623 return false; |
| 624 } | |
| 625 | |
| 626 static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) { | |
| 627 if (!CommandLineFlags::ccstrAtPut(name, &value, origin)) return false; | |
| 628 // Contract: CommandLineFlags always returns a pointer that needs freeing. | |
| 629 FREE_C_HEAP_ARRAY(char, value); | |
| 630 return true; | |
| 631 } | |
| 632 | |
| 633 static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) { | |
| 634 const char* old_value = ""; | |
| 635 if (!CommandLineFlags::ccstrAt(name, &old_value)) return false; | |
| 636 size_t old_len = old_value != NULL ? strlen(old_value) : 0; | |
| 637 size_t new_len = strlen(new_value); | |
| 638 const char* value; | |
| 639 char* free_this_too = NULL; | |
| 640 if (old_len == 0) { | |
| 641 value = new_value; | |
| 642 } else if (new_len == 0) { | |
| 643 value = old_value; | |
| 644 } else { | |
| 645 char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1); | |
| 646 // each new setting adds another LINE to the switch: | |
| 647 sprintf(buf, "%s\n%s", old_value, new_value); | |
| 648 value = buf; | |
| 649 free_this_too = buf; | |
| 650 } | |
| 651 (void) CommandLineFlags::ccstrAtPut(name, &value, origin); | |
| 652 // CommandLineFlags always returns a pointer that needs freeing. | |
| 653 FREE_C_HEAP_ARRAY(char, value); | |
| 654 if (free_this_too != NULL) { | |
| 655 // CommandLineFlags made its own copy, so I must delete my own temp. buffer. | |
| 656 FREE_C_HEAP_ARRAY(char, free_this_too); | |
| 657 } | |
| 658 return true; | |
| 659 } | |
| 660 | |
| 661 bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) { | |
| 662 | |
| 663 // range of acceptable characters spelled out for portability reasons | |
| 664 #define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]" | |
| 665 #define BUFLEN 255 | |
| 666 char name[BUFLEN+1]; | |
| 667 char dummy; | |
| 668 | |
| 669 if (sscanf(arg, "-%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) { | |
| 670 return set_bool_flag(name, false, origin); | |
| 671 } | |
| 672 if (sscanf(arg, "+%" XSTR(BUFLEN) NAME_RANGE "%c", name, &dummy) == 1) { | |
| 673 return set_bool_flag(name, true, origin); | |
| 674 } | |
| 675 | |
| 676 char punct; | |
| 677 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "%c", name, &punct) == 2 && punct == '=') { | |
| 678 const char* value = strchr(arg, '=') + 1; | |
| 679 Flag* flag = Flag::find_flag(name, strlen(name)); | |
| 680 if (flag != NULL && flag->is_ccstr()) { | |
| 681 if (flag->ccstr_accumulates()) { | |
| 682 return append_to_string_flag(name, value, origin); | |
| 683 } else { | |
| 684 if (value[0] == '\0') { | |
| 685 value = NULL; | |
| 686 } | |
| 687 return set_string_flag(name, value, origin); | |
| 688 } | |
| 689 } | |
| 690 } | |
| 691 | |
| 692 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE ":%c", name, &punct) == 2 && punct == '=') { | |
| 693 const char* value = strchr(arg, '=') + 1; | |
| 694 // -XX:Foo:=xxx will reset the string flag to the given value. | |
| 695 if (value[0] == '\0') { | |
| 696 value = NULL; | |
| 697 } | |
| 698 return set_string_flag(name, value, origin); | |
| 699 } | |
| 700 | |
| 701 #define SIGNED_FP_NUMBER_RANGE "[-0123456789.]" | |
| 702 #define SIGNED_NUMBER_RANGE "[-0123456789]" | |
| 703 #define NUMBER_RANGE "[0123456789]" | |
| 704 char value[BUFLEN + 1]; | |
| 705 char value2[BUFLEN + 1]; | |
| 706 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_NUMBER_RANGE "." "%" XSTR(BUFLEN) NUMBER_RANGE "%c", name, value, value2, &dummy) == 3) { | |
| 707 // Looks like a floating-point number -- try again with more lenient format string | |
| 708 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_FP_NUMBER_RANGE "%c", name, value, &dummy) == 2) { | |
| 709 return set_fp_numeric_flag(name, value, origin); | |
| 710 } | |
| 711 } | |
| 712 | |
| 713 #define VALUE_RANGE "[-kmgtKMGT0123456789]" | |
| 714 if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) VALUE_RANGE "%c", name, value, &dummy) == 2) { | |
| 715 return set_numeric_flag(name, value, origin); | |
| 716 } | |
| 717 | |
| 718 return false; | |
| 719 } | |
| 720 | |
| 721 void Arguments::add_string(char*** bldarray, int* count, const char* arg) { | |
| 722 assert(bldarray != NULL, "illegal argument"); | |
| 723 | |
| 724 if (arg == NULL) { | |
| 725 return; | |
| 726 } | |
| 727 | |
| 728 int index = *count; | |
| 729 | |
| 730 // expand the array and add arg to the last element | |
| 731 (*count)++; | |
| 732 if (*bldarray == NULL) { | |
| 733 *bldarray = NEW_C_HEAP_ARRAY(char*, *count); | |
| 734 } else { | |
| 735 *bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count); | |
| 736 } | |
| 737 (*bldarray)[index] = strdup(arg); | |
| 738 } | |
| 739 | |
| 740 void Arguments::build_jvm_args(const char* arg) { | |
| 741 add_string(&_jvm_args_array, &_num_jvm_args, arg); | |
| 742 } | |
| 743 | |
| 744 void Arguments::build_jvm_flags(const char* arg) { | |
| 745 add_string(&_jvm_flags_array, &_num_jvm_flags, arg); | |
| 746 } | |
| 747 | |
| 748 // utility function to return a string that concatenates all | |
| 749 // strings in a given char** array | |
| 750 const char* Arguments::build_resource_string(char** args, int count) { | |
| 751 if (args == NULL || count == 0) { | |
| 752 return NULL; | |
| 753 } | |
| 754 size_t length = strlen(args[0]) + 1; // add 1 for the null terminator | |
| 755 for (int i = 1; i < count; i++) { | |
| 756 length += strlen(args[i]) + 1; // add 1 for a space | |
| 757 } | |
| 758 char* s = NEW_RESOURCE_ARRAY(char, length); | |
| 759 strcpy(s, args[0]); | |
| 760 for (int j = 1; j < count; j++) { | |
| 761 strcat(s, " "); | |
| 762 strcat(s, args[j]); | |
| 763 } | |
| 764 return (const char*) s; | |
| 765 } | |
| 766 | |
| 767 void Arguments::print_on(outputStream* st) { | |
| 768 st->print_cr("VM Arguments:"); | |
| 769 if (num_jvm_flags() > 0) { | |
| 770 st->print("jvm_flags: "); print_jvm_flags_on(st); | |
| 771 } | |
| 772 if (num_jvm_args() > 0) { | |
| 773 st->print("jvm_args: "); print_jvm_args_on(st); | |
| 774 } | |
| 775 st->print_cr("java_command: %s", java_command() ? java_command() : "<unknown>"); | |
| 776 st->print_cr("Launcher Type: %s", _sun_java_launcher); | |
| 777 } | |
| 778 | |
| 779 void Arguments::print_jvm_flags_on(outputStream* st) { | |
| 780 if (_num_jvm_flags > 0) { | |
| 781 for (int i=0; i < _num_jvm_flags; i++) { | |
| 782 st->print("%s ", _jvm_flags_array[i]); | |
| 783 } | |
| 784 st->print_cr(""); | |
| 785 } | |
| 786 } | |
| 787 | |
| 788 void Arguments::print_jvm_args_on(outputStream* st) { | |
| 789 if (_num_jvm_args > 0) { | |
| 790 for (int i=0; i < _num_jvm_args; i++) { | |
| 791 st->print("%s ", _jvm_args_array[i]); | |
| 792 } | |
| 793 st->print_cr(""); | |
| 794 } | |
| 795 } | |
| 796 | |
| 242 | 797 bool Arguments::process_argument(const char* arg, |
| 798 jboolean ignore_unrecognized, FlagValueOrigin origin) { | |
| 799 | |
| 800 JDK_Version since = JDK_Version(); | |
| 0 | 801 |
| 802 if (parse_argument(arg, origin)) { | |
| 803 // do nothing | |
| 242 | 804 } else if (is_newly_obsolete(arg, &since)) { |
| 805 enum { bufsize = 256 }; | |
| 806 char buffer[bufsize]; | |
| 807 since.to_string(buffer, bufsize); | |
| 0 | 808 jio_fprintf(defaultStream::error_stream(), |
| 242 | 809 "Warning: The flag %s has been EOL'd as of %s and will" |
| 810 " be ignored\n", arg, buffer); | |
| 0 | 811 } else { |
| 812 if (!ignore_unrecognized) { | |
| 813 jio_fprintf(defaultStream::error_stream(), | |
| 814 "Unrecognized VM option '%s'\n", arg); | |
| 815 // allow for commandline "commenting out" options like -XX:#+Verbose | |
| 816 if (strlen(arg) == 0 || arg[0] != '#') { | |
| 817 return false; | |
| 818 } | |
| 819 } | |
| 820 } | |
| 821 return true; | |
| 822 } | |
| 823 | |
| 824 bool Arguments::process_settings_file(const char* file_name, bool should_exist, jboolean ignore_unrecognized) { | |
| 825 FILE* stream = fopen(file_name, "rb"); | |
| 826 if (stream == NULL) { | |
| 827 if (should_exist) { | |
| 828 jio_fprintf(defaultStream::error_stream(), | |
| 829 "Could not open settings file %s\n", file_name); | |
| 830 return false; | |
| 831 } else { | |
| 832 return true; | |
| 833 } | |
| 834 } | |
| 835 | |
| 836 char token[1024]; | |
| 837 int pos = 0; | |
| 838 | |
| 839 bool in_white_space = true; | |
| 840 bool in_comment = false; | |
| 841 bool in_quote = false; | |
| 842 char quote_c = 0; | |
| 843 bool result = true; | |
| 844 | |
| 845 int c = getc(stream); | |
| 846 while(c != EOF) { | |
| 847 if (in_white_space) { | |
| 848 if (in_comment) { | |
| 849 if (c == '\n') in_comment = false; | |
| 850 } else { | |
| 851 if (c == '#') in_comment = true; | |
| 852 else if (!isspace(c)) { | |
| 853 in_white_space = false; | |
| 854 token[pos++] = c; | |
| 855 } | |
| 856 } | |
| 857 } else { | |
| 858 if (c == '\n' || (!in_quote && isspace(c))) { | |
| 859 // token ends at newline, or at unquoted whitespace | |
| 860 // this allows a way to include spaces in string-valued options | |
| 861 token[pos] = '\0'; | |
| 862 logOption(token); | |
| 863 result &= process_argument(token, ignore_unrecognized, CONFIG_FILE); | |
| 864 build_jvm_flags(token); | |
| 865 pos = 0; | |
| 866 in_white_space = true; | |
| 867 in_quote = false; | |
| 868 } else if (!in_quote && (c == '\'' || c == '"')) { | |
| 869 in_quote = true; | |
| 870 quote_c = c; | |
| 871 } else if (in_quote && (c == quote_c)) { | |
| 872 in_quote = false; | |
| 873 } else { | |
| 874 token[pos++] = c; | |
| 875 } | |
| 876 } | |
| 877 c = getc(stream); | |
| 878 } | |
| 879 if (pos > 0) { | |
| 880 token[pos] = '\0'; | |
| 881 result &= process_argument(token, ignore_unrecognized, CONFIG_FILE); | |
| 882 build_jvm_flags(token); | |
| 883 } | |
| 884 fclose(stream); | |
| 885 return result; | |
| 886 } | |
| 887 | |
| 888 //============================================================================================================= | |
| 889 // Parsing of properties (-D) | |
| 890 | |
| 891 const char* Arguments::get_property(const char* key) { | |
| 892 return PropertyList_get_value(system_properties(), key); | |
| 893 } | |
| 894 | |
| 895 bool Arguments::add_property(const char* prop) { | |
| 896 const char* eq = strchr(prop, '='); | |
| 897 char* key; | |
| 898 // ns must be static--its address may be stored in a SystemProperty object. | |
| 899 const static char ns[1] = {0}; | |
| 900 char* value = (char *)ns; | |
| 901 | |
| 902 size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop); | |
| 903 key = AllocateHeap(key_len + 1, "add_property"); | |
| 904 strncpy(key, prop, key_len); | |
| 905 key[key_len] = '\0'; | |
| 906 | |
| 907 if (eq != NULL) { | |
| 908 size_t value_len = strlen(prop) - key_len - 1; | |
| 909 value = AllocateHeap(value_len + 1, "add_property"); | |
| 910 strncpy(value, &prop[key_len + 1], value_len + 1); | |
| 911 } | |
| 912 | |
| 913 if (strcmp(key, "java.compiler") == 0) { | |
| 914 process_java_compiler_argument(value); | |
| 915 FreeHeap(key); | |
| 916 if (eq != NULL) { | |
| 917 FreeHeap(value); | |
| 918 } | |
| 919 return true; | |
| 691 | 920 } else if (strcmp(key, "sun.java.command") == 0) { |
| 0 | 921 _java_command = value; |
| 922 | |
|
2129
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2095
diff
changeset
|
923 // Record value in Arguments, but let it get passed to Java. |
| 691 | 924 } else if (strcmp(key, "sun.java.launcher.pid") == 0) { |
| 0 | 925 // launcher.pid property is private and is processed |
| 926 // in process_sun_java_launcher_properties(); | |
| 927 // the sun.java.launcher property is passed on to the java application | |
| 928 FreeHeap(key); | |
| 929 if (eq != NULL) { | |
| 930 FreeHeap(value); | |
| 931 } | |
| 932 return true; | |
| 691 | 933 } else if (strcmp(key, "java.vendor.url.bug") == 0) { |
| 0 | 934 // save it in _java_vendor_url_bug, so JVM fatal error handler can access |
| 935 // its value without going through the property list or making a Java call. | |
| 936 _java_vendor_url_bug = value; | |
| 691 | 937 } else if (strcmp(key, "sun.boot.library.path") == 0) { |
| 938 PropertyList_unique_add(&_system_properties, key, value, true); | |
| 939 return true; | |
| 0 | 940 } |
| 941 // Create new property and add at the end of the list | |
| 942 PropertyList_unique_add(&_system_properties, key, value); | |
| 943 return true; | |
| 944 } | |
| 945 | |
| 946 //=========================================================================================================== | |
| 947 // Setting int/mixed/comp mode flags | |
| 948 | |
| 949 void Arguments::set_mode_flags(Mode mode) { | |
| 950 // Set up default values for all flags. | |
| 951 // If you add a flag to any of the branches below, | |
| 952 // add a default value for it here. | |
| 953 set_java_compiler(false); | |
| 954 _mode = mode; | |
| 955 | |
| 956 // Ensure Agent_OnLoad has the correct initial values. | |
| 957 // This may not be the final mode; mode may change later in onload phase. | |
| 958 PropertyList_unique_add(&_system_properties, "java.vm.info", | |
| 691 | 959 (char*)Abstract_VM_Version::vm_info_string(), false); |
| 0 | 960 |
| 961 UseInterpreter = true; | |
| 962 UseCompiler = true; | |
| 963 UseLoopCounter = true; | |
| 964 | |
| 965 // Default values may be platform/compiler dependent - | |
| 966 // use the saved values | |
| 967 ClipInlining = Arguments::_ClipInlining; | |
| 968 AlwaysCompileLoopMethods = Arguments::_AlwaysCompileLoopMethods; | |
| 969 UseOnStackReplacement = Arguments::_UseOnStackReplacement; | |
| 970 BackgroundCompilation = Arguments::_BackgroundCompilation; | |
| 971 | |
| 972 // Change from defaults based on mode | |
| 973 switch (mode) { | |
| 974 default: | |
| 975 ShouldNotReachHere(); | |
| 976 break; | |
| 977 case _int: | |
| 978 UseCompiler = false; | |
| 979 UseLoopCounter = false; | |
| 980 AlwaysCompileLoopMethods = false; | |
| 981 UseOnStackReplacement = false; | |
| 982 break; | |
| 983 case _mixed: | |
| 984 // same as default | |
| 985 break; | |
| 986 case _comp: | |
| 987 UseInterpreter = false; | |
| 988 BackgroundCompilation = false; | |
| 989 ClipInlining = false; | |
| 990 break; | |
| 991 } | |
| 992 } | |
| 993 | |
| 994 // Conflict: required to use shared spaces (-Xshare:on), but | |
| 995 // incompatible command line options were chosen. | |
| 996 | |
| 997 static void no_shared_spaces() { | |
| 998 if (RequireSharedSpaces) { | |
| 999 jio_fprintf(defaultStream::error_stream(), | |
| 1000 "Class data sharing is inconsistent with other specified options.\n"); | |
| 1001 vm_exit_during_initialization("Unable to use shared archive.", NULL); | |
| 1002 } else { | |
| 1003 FLAG_SET_DEFAULT(UseSharedSpaces, false); | |
| 1004 } | |
| 1005 } | |
| 1006 | |
| 1783 | 1007 void Arguments::set_tiered_flags() { |
| 1008 if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) { | |
| 1009 FLAG_SET_DEFAULT(CompilationPolicyChoice, 2); | |
| 1010 } | |
| 1011 if (CompilationPolicyChoice < 2) { | |
| 1012 vm_exit_during_initialization( | |
| 1013 "Incompatible compilation policy selected", NULL); | |
| 1014 } | |
|
1891
9de67bf4244d
6996136: VM crash in src/share/vm/runtime/virtualspace.cpp:424
iveresov
parents:
1890
diff
changeset
|
1015 // Increase the code cache size - tiered compiles a lot more. |
| 1783 | 1016 if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) { |
| 1017 FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 2); | |
| 1018 } | |
| 1019 } | |
| 1020 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1021 #ifndef KERNEL |
| 0 | 1022 // If the user has chosen ParallelGCThreads > 0, we set UseParNewGC |
| 1023 // if it's not explictly set or unset. If the user has chosen | |
| 1024 // UseParNewGC and not explicitly set ParallelGCThreads we | |
| 1025 // set it, unless this is a single cpu machine. | |
| 1026 void Arguments::set_parnew_gc_flags() { | |
| 1064 | 1027 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC, |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1028 "control point invariant"); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1029 assert(UseParNewGC, "Error"); |
| 0 | 1030 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1031 // Turn off AdaptiveSizePolicy by default for parnew until it is |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1032 // complete. |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1033 if (FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) { |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1034 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1035 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1036 |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1037 if (ParallelGCThreads == 0) { |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1038 FLAG_SET_DEFAULT(ParallelGCThreads, |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1039 Abstract_VM_Version::parallel_worker_threads()); |
| 1064 | 1040 if (ParallelGCThreads == 1) { |
| 0 | 1041 FLAG_SET_DEFAULT(UseParNewGC, false); |
| 1064 | 1042 FLAG_SET_DEFAULT(ParallelGCThreads, 0); |
| 0 | 1043 } |
| 1044 } | |
| 1064 | 1045 if (UseParNewGC) { |
| 1046 // CDS doesn't work with ParNew yet | |
| 0 | 1047 no_shared_spaces(); |
| 1048 | |
| 695 | 1049 // By default YoungPLABSize and OldPLABSize are set to 4096 and 1024 respectively, |
| 0 | 1050 // these settings are default for Parallel Scavenger. For ParNew+Tenured configuration |
| 1051 // we set them to 1024 and 1024. | |
| 1052 // See CR 6362902. | |
| 1053 if (FLAG_IS_DEFAULT(YoungPLABSize)) { | |
| 1054 FLAG_SET_DEFAULT(YoungPLABSize, (intx)1024); | |
| 1055 } | |
| 1056 if (FLAG_IS_DEFAULT(OldPLABSize)) { | |
| 1057 FLAG_SET_DEFAULT(OldPLABSize, (intx)1024); | |
| 1058 } | |
| 1059 | |
| 1064 | 1060 // AlwaysTenure flag should make ParNew promote all at first collection. |
| 0 | 1061 // See CR 6362902. |
| 1062 if (AlwaysTenure) { | |
| 1063 FLAG_SET_CMDLINE(intx, MaxTenuringThreshold, 0); | |
| 1064 } | |
| 695 | 1065 // When using compressed oops, we use local overflow stacks, |
| 1066 // rather than using a global overflow list chained through | |
| 1067 // the klass word of the object's pre-image. | |
| 1068 if (UseCompressedOops && !ParGCUseLocalOverflow) { | |
| 1069 if (!FLAG_IS_DEFAULT(ParGCUseLocalOverflow)) { | |
| 1070 warning("Forcing +ParGCUseLocalOverflow: needed if using compressed references"); | |
| 1071 } | |
| 1072 FLAG_SET_DEFAULT(ParGCUseLocalOverflow, true); | |
| 1073 } | |
| 1074 assert(ParGCUseLocalOverflow || !UseCompressedOops, "Error"); | |
| 0 | 1075 } |
| 1076 } | |
| 1077 | |
| 1078 // Adjust some sizes to suit CMS and/or ParNew needs; these work well on | |
| 1079 // sparc/solaris for certain applications, but would gain from | |
| 1080 // further optimization and tuning efforts, and would almost | |
| 1081 // certainly gain from analysis of platform and environment. | |
| 1082 void Arguments::set_cms_and_parnew_gc_flags() { | |
| 1064 | 1083 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC, "Error"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1084 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
|
1085 |
| 0 | 1086 // If we are using CMS, we prefer to UseParNewGC, |
| 1087 // unless explicitly forbidden. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1088 if (FLAG_IS_DEFAULT(UseParNewGC)) { |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1089 FLAG_SET_ERGO(bool, UseParNewGC, true); |
| 0 | 1090 } |
| 1091 | |
| 1092 // Turn off AdaptiveSizePolicy by default for cms until it is | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1093 // complete. |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1094 if (FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) { |
| 0 | 1095 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false); |
| 1096 } | |
| 1097 | |
| 1098 // In either case, adjust ParallelGCThreads and/or UseParNewGC | |
| 1099 // as needed. | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1100 if (UseParNewGC) { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1101 set_parnew_gc_flags(); |
| 0 | 1102 } |
| 1103 | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1104 // MaxHeapSize is aligned down in collectorPolicy |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1105 size_t max_heap = align_size_down(MaxHeapSize, |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1106 CardTableRS::ct_max_alignment_constraint()); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1107 |
| 0 | 1108 // Now make adjustments for CMS |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1109 intx tenuring_default = (intx)6; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1110 size_t young_gen_per_worker = CMSYoungGenPerWorker; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1111 |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1112 // Preferred young gen size for "short" pauses: |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1113 // upper bound depends on # of threads and NewRatio. |
| 0 | 1114 const uintx parallel_gc_threads = |
| 1115 (ParallelGCThreads == 0 ? 1 : ParallelGCThreads); | |
| 1116 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
|
1117 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
|
1118 size_t preferred_max_new_size = |
| 0 | 1119 align_size_up(preferred_max_new_size_unaligned, os::vm_page_size()); |
| 1120 | |
| 1121 // Unless explicitly requested otherwise, size young gen | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1122 // for "short" pauses ~ CMSYoungGenPerWorker*ParallelGCThreads |
|
886
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1123 |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1124 // 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
|
1125 // 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
|
1126 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
|
1127 |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1128 // 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
|
1129 // 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
|
1130 // preferred_max_new_size. |
| 0 | 1131 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
|
1132 FLAG_SET_ERGO(uintx, MaxNewSize, MAX2(NewSize, preferred_max_new_size)); |
| 0 | 1133 } else { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1134 FLAG_SET_ERGO(uintx, MaxNewSize, preferred_max_new_size); |
| 0 | 1135 } |
| 1064 | 1136 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1137 // Too early to use gclog_or_tty |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1138 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
|
1139 } |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1140 |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1141 // Code along this path potentially sets NewSize and OldSize |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1142 |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1143 assert(max_heap >= InitialHeapSize, "Error"); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1144 assert(max_heap >= NewSize, "Error"); |
| 0 | 1145 |
| 1064 | 1146 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1147 // Too early to use gclog_or_tty |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1148 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
|
1149 " initial_heap_size: " SIZE_FORMAT |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1150 " max_heap: " SIZE_FORMAT, |
| 1064 | 1151 min_heap_size(), InitialHeapSize, max_heap); |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1152 } |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1153 size_t min_new = preferred_max_new_size; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1154 if (FLAG_IS_CMDLINE(NewSize)) { |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1155 min_new = NewSize; |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1156 } |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1157 if (max_heap > min_new && min_heap_size() > min_new) { |
| 0 | 1158 // Unless explicitly requested otherwise, make young gen |
| 1159 // at least min_new, and at most preferred_max_new_size. | |
| 1160 if (FLAG_IS_DEFAULT(NewSize)) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1161 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
|
1162 FLAG_SET_ERGO(uintx, NewSize, MIN2(preferred_max_new_size, NewSize)); |
| 1064 | 1163 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1164 // Too early to use gclog_or_tty |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1165 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
|
1166 } |
| 0 | 1167 } |
| 1168 // Unless explicitly requested otherwise, size old gen | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1169 // so it's NewRatio x of NewSize. |
| 0 | 1170 if (FLAG_IS_DEFAULT(OldSize)) { |
| 1171 if (max_heap > NewSize) { | |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1172 FLAG_SET_ERGO(uintx, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize)); |
| 1064 | 1173 if (PrintGCDetails && Verbose) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1174 // Too early to use gclog_or_tty |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
1175 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
|
1176 } |
| 0 | 1177 } |
| 1178 } | |
| 1179 } | |
| 1180 } | |
| 1181 // Unless explicitly requested otherwise, definitely | |
| 1182 // promote all objects surviving "tenuring_default" scavenges. | |
| 1183 if (FLAG_IS_DEFAULT(MaxTenuringThreshold) && | |
| 1184 FLAG_IS_DEFAULT(SurvivorRatio)) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1185 FLAG_SET_ERGO(intx, MaxTenuringThreshold, tenuring_default); |
| 0 | 1186 } |
| 1187 // If we decided above (or user explicitly requested) | |
| 1188 // `promote all' (via MaxTenuringThreshold := 0), | |
| 1189 // prefer minuscule survivor spaces so as not to waste | |
| 1190 // space for (non-existent) survivors | |
| 1191 if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1192 FLAG_SET_ERGO(intx, SurvivorRatio, MAX2((intx)1024, SurvivorRatio)); |
| 0 | 1193 } |
| 1194 // If OldPLABSize is set and CMSParPromoteBlocksToClaim is not, | |
| 1195 // set CMSParPromoteBlocksToClaim equal to OldPLABSize. | |
| 1196 // This is done in order to make ParNew+CMS configuration to work | |
| 1197 // with YoungPLABSize and OldPLABSize options. | |
| 1198 // See CR 6362902. | |
| 1199 if (!FLAG_IS_DEFAULT(OldPLABSize)) { | |
| 1200 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1201 // 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
|
1202 // is. In this situtation let CMSParPromoteBlocksToClaim follow |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1203 // 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
|
1204 // OldPLABSize. Following OldPLABSize is an ergonomics decision. |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1205 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, OldPLABSize); |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1206 } else { |
| 0 | 1207 // OldPLABSize and CMSParPromoteBlocksToClaim are both set. |
| 1208 // CMSParPromoteBlocksToClaim is a collector-specific flag, so | |
| 1209 // we'll let it to take precedence. | |
| 1210 jio_fprintf(defaultStream::error_stream(), | |
|
886
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1211 "Both OldPLABSize and CMSParPromoteBlocksToClaim" |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1212 " options are specified for the CMS collector." |
|
061cd4d965fc
6862534: -XX:NewRatio completely ignored when combined with -XX:+UseConcMarkSweepG
jmasa
parents:
845
diff
changeset
|
1213 " CMSParPromoteBlocksToClaim will take precedence.\n"); |
| 0 | 1214 } |
| 1215 } | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1216 if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1217 // OldPLAB sizing manually turned off: Use a larger default setting, |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1218 // 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
|
1219 // will slow down scavenges. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1220 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1221 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, 50); // default value before 6631166 |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1222 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1223 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1224 // Overwrite OldPLABSize which is the variable we will internally use everywhere. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1225 FLAG_SET_ERGO(uintx, OldPLABSize, CMSParPromoteBlocksToClaim); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1226 // If either of the static initialization defaults have changed, note this |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1227 // modification. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1228 if (!FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim) || !FLAG_IS_DEFAULT(OldPLABWeight)) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1229 CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1230 } |
| 1284 | 1231 if (PrintGCDetails && Verbose) { |
| 1232 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", | |
| 1233 MarkStackSize / K, MarkStackSizeMax / K); | |
| 1234 tty->print_cr("ConcGCThreads: %u", ConcGCThreads); | |
| 1235 } | |
| 0 | 1236 } |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
1237 #endif // KERNEL |
| 0 | 1238 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1239 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
|
1240 // Object alignment. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1241 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
|
1242 MinObjAlignmentInBytes = ObjectAlignmentInBytes; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1243 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
|
1244 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
|
1245 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
|
1246 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
|
1247 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1248 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
|
1249 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
|
1250 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1251 // 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
|
1252 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
|
1253 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1254 #ifndef KERNEL |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1255 // 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
|
1256 CompactibleFreeListSpace::set_cms_values(); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1257 #endif // KERNEL |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1258 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1259 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1260 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
|
1261 // Object alignment. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1262 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
|
1263 jio_fprintf(defaultStream::error_stream(), |
|
1829
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1264 "error: ObjectAlignmentInBytes=%d must be power of 2\n", |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1265 (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
|
1266 return false; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1267 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1268 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
|
1269 jio_fprintf(defaultStream::error_stream(), |
|
1829
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1270 "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
|
1271 (int)ObjectAlignmentInBytes, BytesPerLong); |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1272 return false; |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1273 } |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1274 // 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
|
1275 // 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
|
1276 // then a saved space from compressed oops. |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1277 if ((int)ObjectAlignmentInBytes > 256) { |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1278 jio_fprintf(defaultStream::error_stream(), |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1279 "error: ObjectAlignmentInBytes=%d must not be greater then 256\n", |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1280 (int)ObjectAlignmentInBytes); |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1281 return false; |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1282 } |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1283 // In case page size is very small. |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1284 if ((int)ObjectAlignmentInBytes >= os::vm_page_size()) { |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1285 jio_fprintf(defaultStream::error_stream(), |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1286 "error: ObjectAlignmentInBytes=%d must be less then page size %d\n", |
|
fe08403130db
6979458: VM crashes when -XX:ObjectAlignmentInBytes is too big
kvn
parents:
1796
diff
changeset
|
1287 (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
|
1288 return false; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1289 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1290 return true; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1291 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1292 |
|
135
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
113
diff
changeset
|
1293 inline uintx max_heap_for_compressed_oops() { |
| 1963 | 1294 // Avoid sign flip. |
| 1295 if (OopEncodingHeapMax < MaxPermSize + os::vm_page_size()) { | |
| 1296 return 0; | |
| 1297 } | |
| 1298 LP64_ONLY(return OopEncodingHeapMax - MaxPermSize - os::vm_page_size()); | |
| 1064 | 1299 NOT_LP64(ShouldNotReachHere(); return 0); |
|
135
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
113
diff
changeset
|
1300 } |
|
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
113
diff
changeset
|
1301 |
| 0 | 1302 bool Arguments::should_auto_select_low_pause_collector() { |
| 1303 if (UseAutoGCSelectPolicy && | |
| 1304 !FLAG_IS_DEFAULT(MaxGCPauseMillis) && | |
| 1305 (MaxGCPauseMillis <= AutoGCSelectPauseMillis)) { | |
| 1306 if (PrintGCDetails) { | |
| 1307 // Cannot use gclog_or_tty yet. | |
| 1308 tty->print_cr("Automatic selection of the low pause collector" | |
| 1309 " based on pause goal of %d (ms)", MaxGCPauseMillis); | |
| 1310 } | |
| 1311 return true; | |
| 1312 } | |
| 1313 return false; | |
| 1314 } | |
| 1315 | |
| 1316 void Arguments::set_ergonomics_flags() { | |
| 1317 // Parallel GC is not compatible with sharing. If one specifies | |
| 1064 | 1318 // that they want sharing explicitly, do not set ergonomics flags. |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
1319 if (DumpSharedSpaces || RequireSharedSpaces) { |
| 0 | 1320 return; |
| 1321 } | |
| 1322 | |
| 1323 if (os::is_server_class_machine() && !force_client_mode ) { | |
| 1324 // If no other collector is requested explicitly, | |
| 1325 // let the VM select the collector based on | |
| 1326 // machine class and automatic selection policy. | |
| 1327 if (!UseSerialGC && | |
| 1328 !UseConcMarkSweepGC && | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1329 !UseG1GC && |
| 0 | 1330 !UseParNewGC && |
| 1331 !DumpSharedSpaces && | |
| 1332 FLAG_IS_DEFAULT(UseParallelGC)) { | |
| 1333 if (should_auto_select_low_pause_collector()) { | |
| 1334 FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true); | |
| 1335 } else { | |
| 1336 FLAG_SET_ERGO(bool, UseParallelGC, true); | |
| 1337 } | |
| 1338 no_shared_spaces(); | |
| 1339 } | |
| 1340 } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1341 |
| 1010 | 1342 #ifndef ZERO |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1343 #ifdef _LP64 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1344 // Check that UseCompressedOops can be set with the max heap size allocated |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1345 // by ergonomics. |
| 187 | 1346 if (MaxHeapSize <= max_heap_for_compressed_oops()) { |
| 1783 | 1347 #if !defined(COMPILER1) || defined(TIERED) |
| 2228 | 1348 if (FLAG_IS_DEFAULT(UseCompressedOops)) { |
| 932 | 1349 FLAG_SET_ERGO(bool, UseCompressedOops, true); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1350 } |
| 1060 | 1351 #endif |
|
325
93befa083681
6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents:
276
diff
changeset
|
1352 #ifdef _WIN64 |
|
93befa083681
6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents:
276
diff
changeset
|
1353 if (UseLargePages && UseCompressedOops) { |
|
93befa083681
6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents:
276
diff
changeset
|
1354 // Cannot allocate guard pages for implicit checks in indexed addressing |
|
93befa083681
6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents:
276
diff
changeset
|
1355 // mode, when large pages are specified on windows. |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
570
diff
changeset
|
1356 // This flag could be switched ON if narrow oop base address is set to 0, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
570
diff
changeset
|
1357 // see code in Universe::initialize_heap(). |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
570
diff
changeset
|
1358 Universe::set_narrow_oop_use_implicit_null_checks(false); |
|
325
93befa083681
6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents:
276
diff
changeset
|
1359 } |
|
93befa083681
6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents:
276
diff
changeset
|
1360 #endif // _WIN64 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1361 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1362 if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) { |
| 344 | 1363 warning("Max heap size too large for Compressed Oops"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1364 FLAG_SET_DEFAULT(UseCompressedOops, false); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1365 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1366 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1367 // 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
|
1368 // in vm_version initialization code. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
76
diff
changeset
|
1369 #endif // _LP64 |
| 1010 | 1370 #endif // !ZERO |
| 0 | 1371 } |
| 1372 | |
| 1373 void Arguments::set_parallel_gc_flags() { | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1374 assert(UseParallelGC || UseParallelOldGC, "Error"); |
| 0 | 1375 // If parallel old was requested, automatically enable parallel scavenge. |
| 1376 if (UseParallelOldGC && !UseParallelGC && FLAG_IS_DEFAULT(UseParallelGC)) { | |
| 1377 FLAG_SET_DEFAULT(UseParallelGC, true); | |
| 1378 } | |
| 1379 | |
| 1380 // If no heap maximum was requested explicitly, use some reasonable fraction | |
| 1381 // of the physical memory, up to a maximum of 1GB. | |
| 1382 if (UseParallelGC) { | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1383 FLAG_SET_ERGO(uintx, ParallelGCThreads, |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1384 Abstract_VM_Version::parallel_worker_threads()); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1385 |
| 0 | 1386 // If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the |
| 1387 // SurvivorRatio has been set, reset their default values to SurvivorRatio + | |
| 1388 // 2. By doing this we make SurvivorRatio also work for Parallel Scavenger. | |
| 1389 // See CR 6362902 for details. | |
| 1390 if (!FLAG_IS_DEFAULT(SurvivorRatio)) { | |
| 1391 if (FLAG_IS_DEFAULT(InitialSurvivorRatio)) { | |
| 1392 FLAG_SET_DEFAULT(InitialSurvivorRatio, SurvivorRatio + 2); | |
| 1393 } | |
| 1394 if (FLAG_IS_DEFAULT(MinSurvivorRatio)) { | |
| 1395 FLAG_SET_DEFAULT(MinSurvivorRatio, SurvivorRatio + 2); | |
| 1396 } | |
| 1397 } | |
| 1398 | |
| 1399 if (UseParallelOldGC) { | |
| 1400 // Par compact uses lower default values since they are treated as | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1401 // minimums. These are different defaults because of the different |
|
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1402 // interpretation and are not ergonomically set. |
| 0 | 1403 if (FLAG_IS_DEFAULT(MarkSweepDeadRatio)) { |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1404 FLAG_SET_DEFAULT(MarkSweepDeadRatio, 1); |
| 0 | 1405 } |
| 1406 if (FLAG_IS_DEFAULT(PermMarkSweepDeadRatio)) { | |
|
13
183f41cf8bfe
6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents:
10
diff
changeset
|
1407 FLAG_SET_DEFAULT(PermMarkSweepDeadRatio, 5); |
| 0 | 1408 } |
| 1409 } | |
| 1410 } | |
| 1411 } | |
| 1412 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1413 void Arguments::set_g1_gc_flags() { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1414 assert(UseG1GC, "Error"); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1415 #ifdef COMPILER1 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1416 FastTLABRefill = false; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1417 #endif |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1418 FLAG_SET_DEFAULT(ParallelGCThreads, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1419 Abstract_VM_Version::parallel_worker_threads()); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1420 if (ParallelGCThreads == 0) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1421 FLAG_SET_DEFAULT(ParallelGCThreads, |
| 751 | 1422 Abstract_VM_Version::parallel_worker_threads()); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1423 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1424 no_shared_spaces(); |
| 751 | 1425 |
| 1284 | 1426 if (FLAG_IS_DEFAULT(MarkStackSize)) { |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
1284
diff
changeset
|
1427 FLAG_SET_DEFAULT(MarkStackSize, 128 * TASKQUEUE_SIZE); |
| 1284 | 1428 } |
| 1429 if (PrintGCDetails && Verbose) { | |
| 1430 tty->print_cr("MarkStackSize: %uk MarkStackSizeMax: %uk", | |
| 1431 MarkStackSize / K, MarkStackSizeMax / K); | |
| 1432 tty->print_cr("ConcGCThreads: %u", ConcGCThreads); | |
| 1433 } | |
| 1356 | 1434 |
| 1435 if (FLAG_IS_DEFAULT(GCTimeRatio) || GCTimeRatio == 0) { | |
| 1436 // In G1, we want the default GC overhead goal to be higher than | |
| 1437 // say in PS. So we set it here to 10%. Otherwise the heap might | |
| 1438 // be expanded more aggressively than we would like it to. In | |
| 1439 // fact, even 10% seems to not be high enough in some cases | |
| 1440 // (especially small GC stress tests that the main thing they do | |
| 1441 // is allocation). We might consider increase it further. | |
| 1442 FLAG_SET_DEFAULT(GCTimeRatio, 9); | |
| 1443 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1444 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1445 |
| 1064 | 1446 void Arguments::set_heap_size() { |
| 1447 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) { | |
| 1448 // Deprecated flag | |
| 1449 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction); | |
| 1450 } | |
| 1451 | |
| 1452 const julong phys_mem = | |
| 1453 FLAG_IS_DEFAULT(MaxRAM) ? MIN2(os::physical_memory(), (julong)MaxRAM) | |
| 1454 : (julong)MaxRAM; | |
| 1455 | |
| 1456 // If the maximum heap size has not been set with -Xmx, | |
| 1457 // then set it as fraction of the size of physical memory, | |
| 1458 // respecting the maximum and minimum sizes of the heap. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1459 if (FLAG_IS_DEFAULT(MaxHeapSize)) { |
| 1064 | 1460 julong reasonable_max = phys_mem / MaxRAMFraction; |
| 1461 | |
| 1462 if (phys_mem <= MaxHeapSize * MinRAMFraction) { | |
| 1463 // Small physical memory, so use a minimum fraction of it for the heap | |
| 1464 reasonable_max = phys_mem / MinRAMFraction; | |
| 1465 } else { | |
| 1466 // Not-small physical memory, so require a heap at least | |
| 1467 // as large as MaxHeapSize | |
| 1468 reasonable_max = MAX2(reasonable_max, (julong)MaxHeapSize); | |
| 1469 } | |
| 1470 if (!FLAG_IS_DEFAULT(ErgoHeapSizeLimit) && ErgoHeapSizeLimit != 0) { | |
| 1471 // Limit the heap size to ErgoHeapSizeLimit | |
| 1472 reasonable_max = MIN2(reasonable_max, (julong)ErgoHeapSizeLimit); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1473 } |
| 1064 | 1474 if (UseCompressedOops) { |
| 1475 // Limit the heap size to the maximum possible when using compressed oops | |
| 1963 | 1476 julong max_coop_heap = (julong)max_heap_for_compressed_oops(); |
| 1477 if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) { | |
| 1478 // Heap should be above HeapBaseMinAddress to get zero based compressed oops | |
| 1479 // but it should be not less than default MaxHeapSize. | |
| 1480 max_coop_heap -= HeapBaseMinAddress; | |
| 1481 } | |
| 1482 reasonable_max = MIN2(reasonable_max, max_coop_heap); | |
| 1064 | 1483 } |
| 1484 reasonable_max = os::allocatable_physical_memory(reasonable_max); | |
| 1485 | |
| 1486 if (!FLAG_IS_DEFAULT(InitialHeapSize)) { | |
| 1487 // An initial heap size was specified on the command line, | |
| 1488 // so be sure that the maximum size is consistent. Done | |
| 1489 // after call to allocatable_physical_memory because that | |
| 1490 // method might reduce the allocation size. | |
| 1491 reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize); | |
| 1492 } | |
| 1493 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1494 if (PrintGCDetails && Verbose) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1495 // Cannot use gclog_or_tty yet. |
| 1064 | 1496 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
|
1497 } |
| 1064 | 1498 FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx)reasonable_max); |
| 1499 } | |
| 1500 | |
| 1501 // If the initial_heap_size has not been set with InitialHeapSize | |
| 1502 // or -Xms, then set it as fraction of the size of physical memory, | |
| 1503 // respecting the maximum and minimum sizes of the heap. | |
| 1504 if (FLAG_IS_DEFAULT(InitialHeapSize)) { | |
|
1074
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1505 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
|
1506 |
|
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1507 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
|
1508 |
|
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1509 reasonable_minimum = os::allocatable_physical_memory(reasonable_minimum); |
|
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1510 |
| 1064 | 1511 julong reasonable_initial = phys_mem / InitialRAMFraction; |
| 1512 | |
|
1074
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1513 reasonable_initial = MAX2(reasonable_initial, reasonable_minimum); |
| 1064 | 1514 reasonable_initial = MIN2(reasonable_initial, (julong)MaxHeapSize); |
| 1515 | |
| 1516 reasonable_initial = os::allocatable_physical_memory(reasonable_initial); | |
| 1517 | |
| 1518 if (PrintGCDetails && Verbose) { | |
| 1519 // Cannot use gclog_or_tty yet. | |
| 1520 tty->print_cr(" Initial heap size " SIZE_FORMAT, (uintx)reasonable_initial); | |
|
1074
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1521 tty->print_cr(" Minimum heap size " SIZE_FORMAT, (uintx)reasonable_minimum); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1522 } |
| 1064 | 1523 FLAG_SET_ERGO(uintx, InitialHeapSize, (uintx)reasonable_initial); |
|
1074
84cb6f20afb3
6900899: vm fails to start when -Xmx value is less than OldSize + NewSize
phh
parents:
1069
diff
changeset
|
1524 set_min_heap_size((uintx)reasonable_minimum); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1525 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1526 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1527 |
| 0 | 1528 // This must be called after ergonomics because we want bytecode rewriting |
| 1529 // if the server compiler is used, or if UseSharedSpaces is disabled. | |
| 1530 void Arguments::set_bytecode_flags() { | |
| 1531 // Better not attempt to store into a read-only space. | |
| 1532 if (UseSharedSpaces) { | |
| 1533 FLAG_SET_DEFAULT(RewriteBytecodes, false); | |
| 1534 FLAG_SET_DEFAULT(RewriteFrequentPairs, false); | |
| 1535 } | |
| 1536 | |
| 1537 if (!RewriteBytecodes) { | |
| 1538 FLAG_SET_DEFAULT(RewriteFrequentPairs, false); | |
| 1539 } | |
| 1540 } | |
| 1541 | |
| 1542 // Aggressive optimization flags -XX:+AggressiveOpts | |
| 1543 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
|
1544 #ifdef COMPILER2 |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1545 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
|
1546 if (FLAG_IS_DEFAULT(EliminateAutoBox)) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1547 FLAG_SET_DEFAULT(EliminateAutoBox, true); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1548 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1549 if (FLAG_IS_DEFAULT(AutoBoxCacheMax)) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1550 FLAG_SET_DEFAULT(AutoBoxCacheMax, 20000); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1551 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1552 |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1553 // 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
|
1554 char buffer[1024]; |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
489
diff
changeset
|
1555 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
|
1556 add_property(buffer); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1557 } |
| 65 | 1558 if (AggressiveOpts && FLAG_IS_DEFAULT(DoEscapeAnalysis)) { |
| 1559 FLAG_SET_DEFAULT(DoEscapeAnalysis, true); | |
| 1560 } | |
|
416
b6cfd754403d
6649622: HotSpot Biased locking needs tuning on latest CPUs
never
parents:
363
diff
changeset
|
1561 if (AggressiveOpts && FLAG_IS_DEFAULT(BiasedLockingStartupDelay)) { |
|
b6cfd754403d
6649622: HotSpot Biased locking needs tuning on latest CPUs
never
parents:
363
diff
changeset
|
1562 FLAG_SET_DEFAULT(BiasedLockingStartupDelay, 500); |
|
b6cfd754403d
6649622: HotSpot Biased locking needs tuning on latest CPUs
never
parents:
363
diff
changeset
|
1563 } |
| 1622 | 1564 if (AggressiveOpts && FLAG_IS_DEFAULT(OptimizeStringConcat)) { |
| 1565 FLAG_SET_DEFAULT(OptimizeStringConcat, true); | |
| 1566 } | |
| 1763 | 1567 if (AggressiveOpts && FLAG_IS_DEFAULT(OptimizeFill)) { |
| 1568 FLAG_SET_DEFAULT(OptimizeFill, true); | |
| 1569 } | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1570 #endif |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1571 |
| 0 | 1572 if (AggressiveOpts) { |
| 61 | 1573 // Sample flag setting code |
| 1574 // if (FLAG_IS_DEFAULT(EliminateZeroing)) { | |
| 1575 // FLAG_SET_DEFAULT(EliminateZeroing, true); | |
| 1576 // } | |
| 0 | 1577 } |
| 1578 } | |
| 1579 | |
| 1580 //=========================================================================================================== | |
| 1581 // Parsing of java.compiler property | |
| 1582 | |
| 1583 void Arguments::process_java_compiler_argument(char* arg) { | |
| 1584 // For backwards compatibility, Djava.compiler=NONE or "" | |
| 1585 // causes us to switch to -Xint mode UNLESS -Xdebug | |
| 1586 // is also specified. | |
| 1587 if (strlen(arg) == 0 || strcasecmp(arg, "NONE") == 0) { | |
| 1588 set_java_compiler(true); // "-Djava.compiler[=...]" most recently seen. | |
| 1589 } | |
| 1590 } | |
| 1591 | |
| 1592 void Arguments::process_java_launcher_argument(const char* launcher, void* extra_info) { | |
| 1593 _sun_java_launcher = strdup(launcher); | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1594 if (strcmp("gamma", _sun_java_launcher) == 0) { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1595 _created_by_gamma_launcher = true; |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1596 } |
| 0 | 1597 } |
| 1598 | |
| 1599 bool Arguments::created_by_java_launcher() { | |
| 1600 assert(_sun_java_launcher != NULL, "property must have value"); | |
| 1601 return strcmp(DEFAULT_JAVA_LAUNCHER, _sun_java_launcher) != 0; | |
| 1602 } | |
| 1603 | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1604 bool Arguments::created_by_gamma_launcher() { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1605 return _created_by_gamma_launcher; |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1606 } |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
1607 |
| 0 | 1608 //=========================================================================================================== |
| 1609 // Parsing of main arguments | |
| 1610 | |
|
1244
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1611 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
|
1612 uintx max, const char* name) { |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1613 // 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
|
1614 // false, otherwise. |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1615 if (val >= min && val <= max) { |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1616 return true; |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1617 } |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1618 jio_fprintf(defaultStream::error_stream(), |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1619 "%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
|
1620 " and " UINTX_FORMAT "\n", |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1621 name, val, min, max); |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1622 return false; |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1623 } |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1624 |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1625 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
|
1626 // 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
|
1627 // false, otherwise. |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1628 if (val >= min ) { |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1629 return true; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1630 } |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1631 jio_fprintf(defaultStream::error_stream(), |
|
2366
1fb790245268
6820066: Check that -XX:ParGCArrayScanChunk has a value larger than zero.
jwilhelm
parents:
2362
diff
changeset
|
1632 "%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
|
1633 name, val, min); |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1634 return false; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1635 } |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1636 |
| 0 | 1637 bool Arguments::verify_percentage(uintx value, const char* name) { |
| 1638 if (value <= 100) { | |
| 1639 return true; | |
| 1640 } | |
| 1641 jio_fprintf(defaultStream::error_stream(), | |
| 1642 "%s of " UINTX_FORMAT " is invalid; must be between 0 and 100\n", | |
| 1643 name, value); | |
| 1644 return false; | |
| 1645 } | |
| 1646 | |
| 1064 | 1647 static void force_serial_gc() { |
| 0 | 1648 FLAG_SET_DEFAULT(UseSerialGC, true); |
| 1649 FLAG_SET_DEFAULT(UseParNewGC, false); | |
| 1650 FLAG_SET_DEFAULT(UseConcMarkSweepGC, false); | |
|
945
68ef3fdcdb76
6872136: CMS: confusing message may be printed when a collector is switched off implicitly
ysr
parents:
932
diff
changeset
|
1651 FLAG_SET_DEFAULT(CMSIncrementalMode, false); // special CMS suboption |
| 0 | 1652 FLAG_SET_DEFAULT(UseParallelGC, false); |
| 1653 FLAG_SET_DEFAULT(UseParallelOldGC, false); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1654 FLAG_SET_DEFAULT(UseG1GC, false); |
| 0 | 1655 } |
| 1656 | |
| 1657 static bool verify_serial_gc_flags() { | |
| 1658 return (UseSerialGC && | |
|
945
68ef3fdcdb76
6872136: CMS: confusing message may be printed when a collector is switched off implicitly
ysr
parents:
932
diff
changeset
|
1659 !(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC || |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
1660 UseParallelGC || UseParallelOldGC)); |
| 0 | 1661 } |
| 1662 | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1663 // Check consistency of GC selection |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1664 bool Arguments::check_gc_consistency() { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1665 bool status = true; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1666 // 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
|
1667 // 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
|
1668 // 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
|
1669 // 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
|
1670 // 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
|
1671 // 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
|
1672 // select conflicting combinations. |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1673 uint i = 0; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1674 if (UseSerialGC) i++; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1675 if (UseConcMarkSweepGC || UseParNewGC) i++; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1676 if (UseParallelGC || UseParallelOldGC) i++; |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
751
diff
changeset
|
1677 if (UseG1GC) i++; |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1678 if (i > 1) { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1679 jio_fprintf(defaultStream::error_stream(), |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1680 "Conflicting collector combinations in option list; " |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1681 "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
|
1682 "allowed\n"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1683 status = false; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1684 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1685 |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1686 return status; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1687 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1688 |
|
1744
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1689 // Check stack pages settings |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1690 bool Arguments::check_stack_pages() |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1691 { |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1692 bool status = true; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1693 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
|
1694 status = status && verify_min_value(StackRedPages, 1, "StackRedPages"); |
|
1867
b6aedd1acdc0
6983240: guarantee((Solaris::min_stack_allowed >= (StackYellowPages+StackRedPages...) wrong
coleenp
parents:
1864
diff
changeset
|
1695 // 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
|
1696 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
|
1697 return status; |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1698 } |
|
f8c5d1bdaad4
6885308: The incorrect -XX:StackRedPages, -XX:StackShadowPages, -XX:StackYellowPages could cause VM crash
ptisnovs
parents:
1681
diff
changeset
|
1699 |
| 0 | 1700 // Check the consistency of vm_init_args |
| 1701 bool Arguments::check_vm_args_consistency() { | |
| 1702 // Method for adding checks for flag consistency. | |
| 1703 // The intent is to warn the user of all possible conflicts, | |
| 1704 // before returning an error. | |
| 1705 // Note: Needs platform-dependent factoring. | |
| 1706 bool status = true; | |
| 1707 | |
| 1708 #if ( (defined(COMPILER2) && defined(SPARC))) | |
| 1709 // NOTE: The call to VM_Version_init depends on the fact that VM_Version_init | |
| 1710 // on sparc doesn't require generation of a stub as is the case on, e.g., | |
| 1711 // x86. Normally, VM_Version_init must be called from init_globals in | |
| 1712 // init.cpp, which is called by the initial java thread *after* arguments | |
| 1713 // have been parsed. VM_Version_init gets called twice on sparc. | |
| 1714 extern void VM_Version_init(); | |
| 1715 VM_Version_init(); | |
| 1716 if (!VM_Version::has_v9()) { | |
| 1717 jio_fprintf(defaultStream::error_stream(), | |
| 1718 "V8 Machine detected, Server requires V9\n"); | |
| 1719 status = false; | |
| 1720 } | |
| 1721 #endif /* COMPILER2 && SPARC */ | |
| 1722 | |
| 1723 // Allow both -XX:-UseStackBanging and -XX:-UseBoundThreads in non-product | |
| 1724 // builds so the cost of stack banging can be measured. | |
| 1725 #if (defined(PRODUCT) && defined(SOLARIS)) | |
| 1726 if (!UseBoundThreads && !UseStackBanging) { | |
| 1727 jio_fprintf(defaultStream::error_stream(), | |
| 1728 "-UseStackBanging conflicts with -UseBoundThreads\n"); | |
| 1729 | |
| 1730 status = false; | |
| 1731 } | |
| 1732 #endif | |
| 1733 | |
| 1734 if (TLABRefillWasteFraction == 0) { | |
| 1735 jio_fprintf(defaultStream::error_stream(), | |
| 1736 "TLABRefillWasteFraction should be a denominator, " | |
| 1737 "not " SIZE_FORMAT "\n", | |
| 1738 TLABRefillWasteFraction); | |
| 1739 status = false; | |
| 1740 } | |
| 1741 | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1742 status = status && verify_percentage(AdaptiveSizePolicyWeight, |
| 0 | 1743 "AdaptiveSizePolicyWeight"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1744 status = status && verify_percentage(AdaptivePermSizeWeight, "AdaptivePermSizeWeight"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1745 status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1746 status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1747 status = status && verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio"); |
| 0 | 1748 |
| 1749 if (MinHeapFreeRatio > MaxHeapFreeRatio) { | |
| 1750 jio_fprintf(defaultStream::error_stream(), | |
| 1751 "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or " | |
| 1752 "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n", | |
| 1753 MinHeapFreeRatio, MaxHeapFreeRatio); | |
| 1754 status = false; | |
| 1755 } | |
| 1756 // Keeping the heap 100% free is hard ;-) so limit it to 99%. | |
| 1757 MinHeapFreeRatio = MIN2(MinHeapFreeRatio, (uintx) 99); | |
| 1758 | |
| 1759 if (FullGCALot && FLAG_IS_DEFAULT(MarkSweepAlwaysCompactCount)) { | |
| 1760 MarkSweepAlwaysCompactCount = 1; // Move objects every gc. | |
| 1761 } | |
| 1762 | |
|
483
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1763 if (UseParallelOldGC && ParallelOldGCSplitALot) { |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1764 // Settings to encourage splitting. |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1765 if (!FLAG_IS_CMDLINE(NewRatio)) { |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1766 FLAG_SET_CMDLINE(intx, NewRatio, 2); |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1767 } |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1768 if (!FLAG_IS_CMDLINE(ScavengeBeforeFullGC)) { |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1769 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1770 } |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1771 } |
|
0f773163217d
6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents:
449
diff
changeset
|
1772 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1773 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit"); |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1774 status = status && verify_percentage(GCTimeLimit, "GCTimeLimit"); |
| 0 | 1775 if (GCTimeLimit == 100) { |
| 1776 // Turn off gc-overhead-limit-exceeded checks | |
| 1777 FLAG_SET_DEFAULT(UseGCOverheadLimit, false); | |
| 1778 } | |
| 1779 | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1780 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit"); |
| 0 | 1781 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1782 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
|
1783 status = status && check_stack_pages(); |
| 0 | 1784 |
| 1785 if (_has_alloc_profile) { | |
| 1786 if (UseParallelGC || UseParallelOldGC) { | |
| 1787 jio_fprintf(defaultStream::error_stream(), | |
| 1788 "error: invalid argument combination.\n" | |
| 1789 "Allocation profiling (-Xaprof) cannot be used together with " | |
| 1790 "Parallel GC (-XX:+UseParallelGC or -XX:+UseParallelOldGC).\n"); | |
| 1791 status = false; | |
| 1792 } | |
| 1793 if (UseConcMarkSweepGC) { | |
| 1794 jio_fprintf(defaultStream::error_stream(), | |
| 1795 "error: invalid argument combination.\n" | |
| 1796 "Allocation profiling (-Xaprof) cannot be used together with " | |
| 1797 "the CMS collector (-XX:+UseConcMarkSweepGC).\n"); | |
| 1798 status = false; | |
| 1799 } | |
| 1800 } | |
| 1801 | |
| 1802 if (CMSIncrementalMode) { | |
| 1803 if (!UseConcMarkSweepGC) { | |
| 1804 jio_fprintf(defaultStream::error_stream(), | |
| 1805 "error: invalid argument combination.\n" | |
| 1806 "The CMS collector (-XX:+UseConcMarkSweepGC) must be " | |
| 1807 "selected in order\nto use CMSIncrementalMode.\n"); | |
| 1808 status = false; | |
| 1809 } else { | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1810 status = status && verify_percentage(CMSIncrementalDutyCycle, |
| 0 | 1811 "CMSIncrementalDutyCycle"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1812 status = status && verify_percentage(CMSIncrementalDutyCycleMin, |
| 0 | 1813 "CMSIncrementalDutyCycleMin"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1814 status = status && verify_percentage(CMSIncrementalSafetyFactor, |
| 0 | 1815 "CMSIncrementalSafetyFactor"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1816 status = status && verify_percentage(CMSIncrementalOffset, |
| 0 | 1817 "CMSIncrementalOffset"); |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
1818 status = status && verify_percentage(CMSExpAvgFactor, |
| 0 | 1819 "CMSExpAvgFactor"); |
| 1820 // If it was not set on the command line, set | |
| 1821 // CMSInitiatingOccupancyFraction to 1 so icms can initiate cycles early. | |
| 1822 if (CMSInitiatingOccupancyFraction < 0) { | |
| 1823 FLAG_SET_DEFAULT(CMSInitiatingOccupancyFraction, 1); | |
| 1824 } | |
| 1825 } | |
| 1826 } | |
| 1827 | |
| 1828 // CMS space iteration, which FLSVerifyAllHeapreferences entails, | |
| 1829 // insists that we hold the requisite locks so that the iteration is | |
| 1830 // MT-safe. For the verification at start-up and shut-down, we don't | |
| 1831 // yet have a good way of acquiring and releasing these locks, | |
| 1832 // which are not visible at the CollectedHeap level. We want to | |
| 1833 // be able to acquire these locks and then do the iteration rather | |
| 1834 // than just disable the lock verification. This will be fixed under | |
| 1835 // bug 4788986. | |
| 1836 if (UseConcMarkSweepGC && FLSVerifyAllHeapReferences) { | |
| 1837 if (VerifyGCStartAt == 0) { | |
| 1838 warning("Heap verification at start-up disabled " | |
| 1839 "(due to current incompatibility with FLSVerifyAllHeapReferences)"); | |
| 1840 VerifyGCStartAt = 1; // Disable verification at start-up | |
| 1841 } | |
| 1842 if (VerifyBeforeExit) { | |
| 1843 warning("Heap verification at shutdown disabled " | |
| 1844 "(due to current incompatibility with FLSVerifyAllHeapReferences)"); | |
| 1845 VerifyBeforeExit = false; // Disable verification at shutdown | |
| 1846 } | |
| 1847 } | |
| 1848 | |
| 1849 // Note: only executed in non-PRODUCT mode | |
| 1850 if (!UseAsyncConcMarkSweepGC && | |
| 1851 (ExplicitGCInvokesConcurrent || | |
| 1852 ExplicitGCInvokesConcurrentAndUnloadsClasses)) { | |
| 1853 jio_fprintf(defaultStream::error_stream(), | |
| 1854 "error: +ExplictGCInvokesConcurrent[AndUnloadsClasses] conflicts" | |
| 1855 " with -UseAsyncConcMarkSweepGC"); | |
| 1856 status = false; | |
| 1857 } | |
| 1858 | |
|
2366
1fb790245268
6820066: Check that -XX:ParGCArrayScanChunk has a value larger than zero.
jwilhelm
parents:
2362
diff
changeset
|
1859 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
|
1860 |
|
2174
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
1861 #ifndef SERIALGC |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
1862 if (UseG1GC) { |
|
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
1863 status = status && verify_percentage(InitiatingHeapOccupancyPercent, |
|
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
1864 "InitiatingHeapOccupancyPercent"); |
|
2174
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
1865 status = status && verify_min_value(G1RefProcDrainInterval, 1, |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
1866 "G1RefProcDrainInterval"); |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
1867 status = status && verify_min_value((intx)G1ConcMarkStepDurationMillis, 1, |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
1868 "G1ConcMarkStepDurationMillis"); |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
1869 } |
|
2174
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2129
diff
changeset
|
1870 #endif |
|
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1257
diff
changeset
|
1871 |
|
1244
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1872 status = status && verify_interval(RefDiscoveryPolicy, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1873 ReferenceProcessor::DiscoveryPolicyMin, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1874 ReferenceProcessor::DiscoveryPolicyMax, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1875 "RefDiscoveryPolicy"); |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1876 |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1877 // 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
|
1878 // expression. |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1879 status = status && verify_interval(TLABWasteTargetPercent, |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1880 1, 100, "TLABWasteTargetPercent"); |
|
745c853ee57f
6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents:
1188
diff
changeset
|
1881 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
1882 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
|
1883 |
| 0 | 1884 return status; |
| 1885 } | |
| 1886 | |
| 1887 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore, | |
| 1888 const char* option_type) { | |
| 1889 if (ignore) return false; | |
| 1890 | |
| 1891 const char* spacer = " "; | |
| 1892 if (option_type == NULL) { | |
| 1893 option_type = ++spacer; // Set both to the empty string. | |
| 1894 } | |
| 1895 | |
| 1896 if (os::obsolete_option(option)) { | |
| 1897 jio_fprintf(defaultStream::error_stream(), | |
| 1898 "Obsolete %s%soption: %s\n", option_type, spacer, | |
| 1899 option->optionString); | |
| 1900 return false; | |
| 1901 } else { | |
| 1902 jio_fprintf(defaultStream::error_stream(), | |
| 1903 "Unrecognized %s%soption: %s\n", option_type, spacer, | |
| 1904 option->optionString); | |
| 1905 return true; | |
| 1906 } | |
| 1907 } | |
| 1908 | |
| 1909 static const char* user_assertion_options[] = { | |
| 1910 "-da", "-ea", "-disableassertions", "-enableassertions", 0 | |
| 1911 }; | |
| 1912 | |
| 1913 static const char* system_assertion_options[] = { | |
| 1914 "-dsa", "-esa", "-disablesystemassertions", "-enablesystemassertions", 0 | |
| 1915 }; | |
| 1916 | |
| 1917 // Return true if any of the strings in null-terminated array 'names' matches. | |
| 1918 // If tail_allowed is true, then the tail must begin with a colon; otherwise, | |
| 1919 // the option must match exactly. | |
| 1920 static bool match_option(const JavaVMOption* option, const char** names, const char** tail, | |
| 1921 bool tail_allowed) { | |
| 1922 for (/* empty */; *names != NULL; ++names) { | |
| 1923 if (match_option(option, *names, tail)) { | |
| 1924 if (**tail == '\0' || tail_allowed && **tail == ':') { | |
| 1925 return true; | |
| 1926 } | |
| 1927 } | |
| 1928 } | |
| 1929 return false; | |
| 1930 } | |
| 1931 | |
| 1284 | 1932 bool Arguments::parse_uintx(const char* value, |
| 1933 uintx* uintx_arg, | |
| 1934 uintx min_size) { | |
| 1935 | |
| 1936 // Check the sign first since atomull() parses only unsigned values. | |
| 1937 bool value_is_positive = !(*value == '-'); | |
| 1938 | |
| 1939 if (value_is_positive) { | |
| 1940 julong n; | |
| 1941 bool good_return = atomull(value, &n); | |
| 1942 if (good_return) { | |
| 1943 bool above_minimum = n >= min_size; | |
| 1944 bool value_is_too_large = n > max_uintx; | |
| 1945 | |
| 1946 if (above_minimum && !value_is_too_large) { | |
| 1947 *uintx_arg = n; | |
| 1948 return true; | |
| 1949 } | |
| 1950 } | |
| 1951 } | |
| 1952 return false; | |
| 1953 } | |
| 1954 | |
| 0 | 1955 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
|
1956 julong* long_arg, |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
1957 julong min_size) { |
|
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
1958 if (!atomull(s, long_arg)) return arg_unreadable; |
| 0 | 1959 return check_memory_size(*long_arg, min_size); |
| 1960 } | |
| 1961 | |
| 1962 // Parse JavaVMInitArgs structure | |
| 1963 | |
| 1964 jint Arguments::parse_vm_init_args(const JavaVMInitArgs* args) { | |
| 1965 // For components of the system classpath. | |
| 1966 SysClassPath scp(Arguments::get_sysclasspath()); | |
| 1967 bool scp_assembly_required = false; | |
| 1968 | |
| 1969 // Save default settings for some mode flags | |
| 1970 Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods; | |
| 1971 Arguments::_UseOnStackReplacement = UseOnStackReplacement; | |
| 1972 Arguments::_ClipInlining = ClipInlining; | |
| 1973 Arguments::_BackgroundCompilation = BackgroundCompilation; | |
| 1974 | |
| 1975 // Parse JAVA_TOOL_OPTIONS environment variable (if present) | |
| 1976 jint result = parse_java_tool_options_environment_variable(&scp, &scp_assembly_required); | |
| 1977 if (result != JNI_OK) { | |
| 1978 return result; | |
| 1979 } | |
| 1980 | |
| 1981 // Parse JavaVMInitArgs structure passed in | |
| 1982 result = parse_each_vm_init_arg(args, &scp, &scp_assembly_required, COMMAND_LINE); | |
| 1983 if (result != JNI_OK) { | |
| 1984 return result; | |
| 1985 } | |
| 1986 | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1987 if (AggressiveOpts) { |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1988 // Insert alt-rt.jar between user-specified bootclasspath |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1989 // prefix and the default bootclasspath. os::set_boot_path() |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1990 // uses meta_index_dir as the default bootclasspath directory. |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1991 const char* altclasses_jar = "alt-rt.jar"; |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1992 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
|
1993 strlen(altclasses_jar); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1994 char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1995 strcpy(altclasses_path, get_meta_index_dir()); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1996 strcat(altclasses_path, altclasses_jar); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1997 scp.add_suffix_to_prefix(altclasses_path); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1998 scp_assembly_required = true; |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
1999 FREE_C_HEAP_ARRAY(char, altclasses_path); |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2000 } |
|
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2001 |
| 0 | 2002 // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM) |
| 2003 result = parse_java_options_environment_variable(&scp, &scp_assembly_required); | |
| 2004 if (result != JNI_OK) { | |
| 2005 return result; | |
| 2006 } | |
| 2007 | |
| 2008 // Do final processing now that all arguments have been parsed | |
| 2009 result = finalize_vm_init_args(&scp, scp_assembly_required); | |
| 2010 if (result != JNI_OK) { | |
| 2011 return result; | |
| 2012 } | |
| 2013 | |
| 2014 return JNI_OK; | |
| 2015 } | |
| 2016 | |
| 2017 jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, | |
| 2018 SysClassPath* scp_p, | |
| 2019 bool* scp_assembly_required_p, | |
| 2020 FlagValueOrigin origin) { | |
| 2021 // Remaining part of option string | |
| 2022 const char* tail; | |
| 2023 | |
| 2024 // iterate over arguments | |
| 2025 for (int index = 0; index < args->nOptions; index++) { | |
| 2026 bool is_absolute_path = false; // for -agentpath vs -agentlib | |
| 2027 | |
| 2028 const JavaVMOption* option = args->options + index; | |
| 2029 | |
| 2030 if (!match_option(option, "-Djava.class.path", &tail) && | |
| 2031 !match_option(option, "-Dsun.java.command", &tail) && | |
| 2032 !match_option(option, "-Dsun.java.launcher", &tail)) { | |
| 2033 | |
| 2034 // add all jvm options to the jvm_args string. This string | |
| 2035 // is used later to set the java.vm.args PerfData string constant. | |
| 2036 // the -Djava.class.path and the -Dsun.java.command options are | |
| 2037 // omitted from jvm_args string as each have their own PerfData | |
| 2038 // string constant object. | |
| 2039 build_jvm_args(option->optionString); | |
| 2040 } | |
| 2041 | |
| 2042 // -verbose:[class/gc/jni] | |
| 2043 if (match_option(option, "-verbose", &tail)) { | |
| 2044 if (!strcmp(tail, ":class") || !strcmp(tail, "")) { | |
| 2045 FLAG_SET_CMDLINE(bool, TraceClassLoading, true); | |
| 2046 FLAG_SET_CMDLINE(bool, TraceClassUnloading, true); | |
| 2047 } else if (!strcmp(tail, ":gc")) { | |
| 2048 FLAG_SET_CMDLINE(bool, PrintGC, true); | |
| 2049 } else if (!strcmp(tail, ":jni")) { | |
| 2050 FLAG_SET_CMDLINE(bool, PrintJNIResolving, true); | |
| 2051 } | |
| 2052 // -da / -ea / -disableassertions / -enableassertions | |
| 2053 // These accept an optional class/package name separated by a colon, e.g., | |
| 2054 // -da:java.lang.Thread. | |
| 2055 } else if (match_option(option, user_assertion_options, &tail, true)) { | |
| 2056 bool enable = option->optionString[1] == 'e'; // char after '-' is 'e' | |
| 2057 if (*tail == '\0') { | |
| 2058 JavaAssertions::setUserClassDefault(enable); | |
| 2059 } else { | |
| 2060 assert(*tail == ':', "bogus match by match_option()"); | |
| 2061 JavaAssertions::addOption(tail + 1, enable); | |
| 2062 } | |
| 2063 // -dsa / -esa / -disablesystemassertions / -enablesystemassertions | |
| 2064 } else if (match_option(option, system_assertion_options, &tail, false)) { | |
| 2065 bool enable = option->optionString[1] == 'e'; // char after '-' is 'e' | |
| 2066 JavaAssertions::setSystemClassDefault(enable); | |
| 2067 // -bootclasspath: | |
| 2068 } else if (match_option(option, "-Xbootclasspath:", &tail)) { | |
| 2069 scp_p->reset_path(tail); | |
| 2070 *scp_assembly_required_p = true; | |
| 2071 // -bootclasspath/a: | |
| 2072 } else if (match_option(option, "-Xbootclasspath/a:", &tail)) { | |
| 2073 scp_p->add_suffix(tail); | |
| 2074 *scp_assembly_required_p = true; | |
| 2075 // -bootclasspath/p: | |
| 2076 } else if (match_option(option, "-Xbootclasspath/p:", &tail)) { | |
| 2077 scp_p->add_prefix(tail); | |
| 2078 *scp_assembly_required_p = true; | |
| 2079 // -Xrun | |
| 2080 } else if (match_option(option, "-Xrun", &tail)) { | |
|
531
40ee984935b9
6792705: Add JAR file to bootclasspath when using AggressiveOpts
phh
parents:
513
diff
changeset
|
2081 if (tail != NULL) { |
| 0 | 2082 const char* pos = strchr(tail, ':'); |
| 2083 size_t len = (pos == NULL) ? strlen(tail) : pos - tail; | |
| 2084 char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len); | |
| 2085 name[len] = '\0'; | |
| 2086 | |
| 2087 char *options = NULL; | |
| 2088 if(pos != NULL) { | |
| 2089 size_t len2 = strlen(pos+1) + 1; // options start after ':'. Final zero must be copied. | |
| 2090 options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2), pos+1, len2); | |
| 2091 } | |
| 2092 #ifdef JVMTI_KERNEL | |
| 2093 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) { | |
| 2094 warning("profiling and debugging agents are not supported with Kernel VM"); | |
| 2095 } else | |
| 2096 #endif // JVMTI_KERNEL | |
| 2097 add_init_library(name, options); | |
| 2098 } | |
| 2099 // -agentlib and -agentpath | |
| 2100 } else if (match_option(option, "-agentlib:", &tail) || | |
| 2101 (is_absolute_path = match_option(option, "-agentpath:", &tail))) { | |
| 2102 if(tail != NULL) { | |
| 2103 const char* pos = strchr(tail, '='); | |
| 2104 size_t len = (pos == NULL) ? strlen(tail) : pos - tail; | |
| 2105 char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len); | |
| 2106 name[len] = '\0'; | |
| 2107 | |
| 2108 char *options = NULL; | |
| 2109 if(pos != NULL) { | |
| 2110 options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1), pos + 1); | |
| 2111 } | |
| 2112 #ifdef JVMTI_KERNEL | |
| 2113 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) { | |
| 2114 warning("profiling and debugging agents are not supported with Kernel VM"); | |
| 2115 } else | |
| 2116 #endif // JVMTI_KERNEL | |
| 2117 add_init_agent(name, options, is_absolute_path); | |
| 2118 | |
| 2119 } | |
| 2120 // -javaagent | |
| 2121 } else if (match_option(option, "-javaagent:", &tail)) { | |
| 2122 if(tail != NULL) { | |
| 2123 char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1), tail); | |
| 2124 add_init_agent("instrument", options, false); | |
| 2125 } | |
| 2126 // -Xnoclassgc | |
| 2127 } else if (match_option(option, "-Xnoclassgc", &tail)) { | |
| 2128 FLAG_SET_CMDLINE(bool, ClassUnloading, false); | |
| 2129 // -Xincgc: i-CMS | |
| 2130 } else if (match_option(option, "-Xincgc", &tail)) { | |
| 2131 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true); | |
| 2132 FLAG_SET_CMDLINE(bool, CMSIncrementalMode, true); | |
| 2133 // -Xnoincgc: no i-CMS | |
| 2134 } else if (match_option(option, "-Xnoincgc", &tail)) { | |
| 2135 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, false); | |
| 2136 FLAG_SET_CMDLINE(bool, CMSIncrementalMode, false); | |
| 2137 // -Xconcgc | |
| 2138 } else if (match_option(option, "-Xconcgc", &tail)) { | |
| 2139 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, true); | |
| 2140 // -Xnoconcgc | |
| 2141 } else if (match_option(option, "-Xnoconcgc", &tail)) { | |
| 2142 FLAG_SET_CMDLINE(bool, UseConcMarkSweepGC, false); | |
| 2143 // -Xbatch | |
| 2144 } else if (match_option(option, "-Xbatch", &tail)) { | |
| 2145 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); | |
| 2146 // -Xmn for compatibility with other JVM vendors | |
| 2147 } else if (match_option(option, "-Xmn", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2148 julong long_initial_eden_size = 0; |
| 0 | 2149 ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1); |
| 2150 if (errcode != arg_in_range) { | |
| 2151 jio_fprintf(defaultStream::error_stream(), | |
| 2152 "Invalid initial eden size: %s\n", option->optionString); | |
| 2153 describe_range_error(errcode); | |
| 2154 return JNI_EINVAL; | |
| 2155 } | |
| 1064 | 2156 FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size); |
| 2157 FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size); | |
| 0 | 2158 // -Xms |
| 2159 } else if (match_option(option, "-Xms", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2160 julong long_initial_heap_size = 0; |
| 0 | 2161 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 1); |
| 2162 if (errcode != arg_in_range) { | |
| 2163 jio_fprintf(defaultStream::error_stream(), | |
| 2164 "Invalid initial heap size: %s\n", option->optionString); | |
| 2165 describe_range_error(errcode); | |
| 2166 return JNI_EINVAL; | |
| 2167 } | |
| 1064 | 2168 FLAG_SET_CMDLINE(uintx, InitialHeapSize, (uintx)long_initial_heap_size); |
| 0 | 2169 // Currently the minimum size and the initial heap sizes are the same. |
| 1064 | 2170 set_min_heap_size(InitialHeapSize); |
| 0 | 2171 // -Xmx |
| 2172 } else if (match_option(option, "-Xmx", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2173 julong long_max_heap_size = 0; |
| 0 | 2174 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1); |
| 2175 if (errcode != arg_in_range) { | |
| 2176 jio_fprintf(defaultStream::error_stream(), | |
| 2177 "Invalid maximum heap size: %s\n", option->optionString); | |
| 2178 describe_range_error(errcode); | |
| 2179 return JNI_EINVAL; | |
| 2180 } | |
| 1064 | 2181 FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size); |
| 0 | 2182 // Xmaxf |
| 2183 } else if (match_option(option, "-Xmaxf", &tail)) { | |
| 2184 int maxf = (int)(atof(tail) * 100); | |
| 2185 if (maxf < 0 || maxf > 100) { | |
| 2186 jio_fprintf(defaultStream::error_stream(), | |
| 2187 "Bad max heap free percentage size: %s\n", | |
| 2188 option->optionString); | |
| 2189 return JNI_EINVAL; | |
| 2190 } else { | |
| 2191 FLAG_SET_CMDLINE(uintx, MaxHeapFreeRatio, maxf); | |
| 2192 } | |
| 2193 // Xminf | |
| 2194 } else if (match_option(option, "-Xminf", &tail)) { | |
| 2195 int minf = (int)(atof(tail) * 100); | |
| 2196 if (minf < 0 || minf > 100) { | |
| 2197 jio_fprintf(defaultStream::error_stream(), | |
| 2198 "Bad min heap free percentage size: %s\n", | |
| 2199 option->optionString); | |
| 2200 return JNI_EINVAL; | |
| 2201 } else { | |
| 2202 FLAG_SET_CMDLINE(uintx, MinHeapFreeRatio, minf); | |
| 2203 } | |
| 2204 // -Xss | |
| 2205 } else if (match_option(option, "-Xss", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2206 julong long_ThreadStackSize = 0; |
| 0 | 2207 ArgsRange errcode = parse_memory_size(tail, &long_ThreadStackSize, 1000); |
| 2208 if (errcode != arg_in_range) { | |
| 2209 jio_fprintf(defaultStream::error_stream(), | |
| 2210 "Invalid thread stack size: %s\n", option->optionString); | |
| 2211 describe_range_error(errcode); | |
| 2212 return JNI_EINVAL; | |
| 2213 } | |
| 2214 // Internally track ThreadStackSize in units of 1024 bytes. | |
| 2215 FLAG_SET_CMDLINE(intx, ThreadStackSize, | |
| 2216 round_to((int)long_ThreadStackSize, K) / K); | |
| 2217 // -Xoss | |
| 2218 } else if (match_option(option, "-Xoss", &tail)) { | |
| 2219 // HotSpot does not have separate native and Java stacks, ignore silently for compatibility | |
| 2220 // -Xmaxjitcodesize | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2002
diff
changeset
|
2221 } 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
|
2222 match_option(option, "-XX:ReservedCodeCacheSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2223 julong long_ReservedCodeCacheSize = 0; |
| 0 | 2224 ArgsRange errcode = parse_memory_size(tail, &long_ReservedCodeCacheSize, |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2225 (size_t)InitialCodeCacheSize); |
| 0 | 2226 if (errcode != arg_in_range) { |
| 2227 jio_fprintf(defaultStream::error_stream(), | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2002
diff
changeset
|
2228 "Invalid maximum code cache size: %s. Should be greater than InitialCodeCacheSize=%dK\n", |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2002
diff
changeset
|
2229 option->optionString, InitialCodeCacheSize/K); |
| 0 | 2230 describe_range_error(errcode); |
| 2231 return JNI_EINVAL; | |
| 2232 } | |
| 2233 FLAG_SET_CMDLINE(uintx, ReservedCodeCacheSize, (uintx)long_ReservedCodeCacheSize); | |
| 2234 // -green | |
| 2235 } else if (match_option(option, "-green", &tail)) { | |
| 2236 jio_fprintf(defaultStream::error_stream(), | |
| 2237 "Green threads support not available\n"); | |
| 2238 return JNI_EINVAL; | |
| 2239 // -native | |
| 2240 } else if (match_option(option, "-native", &tail)) { | |
| 2241 // HotSpot always uses native threads, ignore silently for compatibility | |
| 2242 // -Xsqnopause | |
| 2243 } else if (match_option(option, "-Xsqnopause", &tail)) { | |
| 2244 // EVM option, ignore silently for compatibility | |
| 2245 // -Xrs | |
| 2246 } else if (match_option(option, "-Xrs", &tail)) { | |
| 2247 // Classic/EVM option, new functionality | |
| 2248 FLAG_SET_CMDLINE(bool, ReduceSignalUsage, true); | |
| 2249 } else if (match_option(option, "-Xusealtsigs", &tail)) { | |
| 2250 // change default internal VM signals used - lower case for back compat | |
| 2251 FLAG_SET_CMDLINE(bool, UseAltSigs, true); | |
| 2252 // -Xoptimize | |
| 2253 } else if (match_option(option, "-Xoptimize", &tail)) { | |
| 2254 // EVM option, ignore silently for compatibility | |
| 2255 // -Xprof | |
| 2256 } else if (match_option(option, "-Xprof", &tail)) { | |
| 2257 #ifndef FPROF_KERNEL | |
| 2258 _has_profile = true; | |
| 2259 #else // FPROF_KERNEL | |
| 2260 // do we have to exit? | |
| 2261 warning("Kernel VM does not support flat profiling."); | |
| 2262 #endif // FPROF_KERNEL | |
| 2263 // -Xaprof | |
| 2264 } else if (match_option(option, "-Xaprof", &tail)) { | |
| 2265 _has_alloc_profile = true; | |
| 2266 // -Xconcurrentio | |
| 2267 } else if (match_option(option, "-Xconcurrentio", &tail)) { | |
| 2268 FLAG_SET_CMDLINE(bool, UseLWPSynchronization, true); | |
| 2269 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false); | |
| 2270 FLAG_SET_CMDLINE(intx, DeferThrSuspendLoopCount, 1); | |
| 2271 FLAG_SET_CMDLINE(bool, UseTLAB, false); | |
| 2272 FLAG_SET_CMDLINE(uintx, NewSizeThreadIncrease, 16 * K); // 20Kb per thread added to new generation | |
| 2273 | |
| 2274 // -Xinternalversion | |
| 2275 } else if (match_option(option, "-Xinternalversion", &tail)) { | |
| 2276 jio_fprintf(defaultStream::output_stream(), "%s\n", | |
| 2277 VM_Version::internal_vm_info_string()); | |
| 2278 vm_exit(0); | |
| 2279 #ifndef PRODUCT | |
| 2280 // -Xprintflags | |
| 2281 } else if (match_option(option, "-Xprintflags", &tail)) { | |
| 2282 CommandLineFlags::printFlags(); | |
| 2283 vm_exit(0); | |
| 2284 #endif | |
| 2285 // -D | |
| 2286 } else if (match_option(option, "-D", &tail)) { | |
| 2287 if (!add_property(tail)) { | |
| 2288 return JNI_ENOMEM; | |
| 2289 } | |
| 2290 // Out of the box management support | |
| 2291 if (match_option(option, "-Dcom.sun.management", &tail)) { | |
| 2292 FLAG_SET_CMDLINE(bool, ManagementServer, true); | |
| 2293 } | |
| 2294 // -Xint | |
| 2295 } else if (match_option(option, "-Xint", &tail)) { | |
| 2296 set_mode_flags(_int); | |
| 2297 // -Xmixed | |
| 2298 } else if (match_option(option, "-Xmixed", &tail)) { | |
| 2299 set_mode_flags(_mixed); | |
| 2300 // -Xcomp | |
| 2301 } else if (match_option(option, "-Xcomp", &tail)) { | |
| 2302 // for testing the compiler; turn off all flags that inhibit compilation | |
| 2303 set_mode_flags(_comp); | |
| 2304 | |
| 2305 // -Xshare:dump | |
| 2306 } else if (match_option(option, "-Xshare:dump", &tail)) { | |
| 2307 #ifdef TIERED | |
| 2308 FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true); | |
| 2309 set_mode_flags(_int); // Prevent compilation, which creates objects | |
| 2310 #elif defined(COMPILER2) | |
| 2311 vm_exit_during_initialization( | |
| 2312 "Dumping a shared archive is not supported on the Server JVM.", NULL); | |
| 2313 #elif defined(KERNEL) | |
| 2314 vm_exit_during_initialization( | |
| 2315 "Dumping a shared archive is not supported on the Kernel JVM.", NULL); | |
| 2316 #else | |
| 2317 FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true); | |
| 2318 set_mode_flags(_int); // Prevent compilation, which creates objects | |
| 2319 #endif | |
| 2320 // -Xshare:on | |
| 2321 } else if (match_option(option, "-Xshare:on", &tail)) { | |
| 2322 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true); | |
| 2323 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, true); | |
| 2324 // -Xshare:auto | |
| 2325 } else if (match_option(option, "-Xshare:auto", &tail)) { | |
| 2326 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true); | |
| 2327 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false); | |
| 2328 // -Xshare:off | |
| 2329 } else if (match_option(option, "-Xshare:off", &tail)) { | |
| 2330 FLAG_SET_CMDLINE(bool, UseSharedSpaces, false); | |
| 2331 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false); | |
| 2332 | |
| 2333 // -Xverify | |
| 2334 } else if (match_option(option, "-Xverify", &tail)) { | |
| 2335 if (strcmp(tail, ":all") == 0 || strcmp(tail, "") == 0) { | |
| 2336 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, true); | |
| 2337 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true); | |
| 2338 } else if (strcmp(tail, ":remote") == 0) { | |
| 2339 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, false); | |
| 2340 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true); | |
| 2341 } else if (strcmp(tail, ":none") == 0) { | |
| 2342 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, false); | |
| 2343 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, false); | |
| 2344 } else if (is_bad_option(option, args->ignoreUnrecognized, "verification")) { | |
| 2345 return JNI_EINVAL; | |
| 2346 } | |
| 2347 // -Xdebug | |
| 2348 } else if (match_option(option, "-Xdebug", &tail)) { | |
| 2349 // note this flag has been used, then ignore | |
| 2350 set_xdebug_mode(true); | |
| 2351 // -Xnoagent | |
| 2352 } else if (match_option(option, "-Xnoagent", &tail)) { | |
| 2353 // For compatibility with classic. HotSpot refuses to load the old style agent.dll. | |
| 2354 } else if (match_option(option, "-Xboundthreads", &tail)) { | |
| 2355 // Bind user level threads to kernel threads (Solaris only) | |
| 2356 FLAG_SET_CMDLINE(bool, UseBoundThreads, true); | |
| 2357 } else if (match_option(option, "-Xloggc:", &tail)) { | |
| 2358 // Redirect GC output to the file. -Xloggc:<filename> | |
| 2359 // ostream_init_log(), when called will use this filename | |
| 2360 // to initialize a fileStream. | |
| 2361 _gc_log_filename = strdup(tail); | |
| 2362 FLAG_SET_CMDLINE(bool, PrintGC, true); | |
| 2363 FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true); | |
| 2364 FLAG_SET_CMDLINE(bool, TraceClassUnloading, true); | |
| 2365 | |
| 2366 // JNI hooks | |
| 2367 } else if (match_option(option, "-Xcheck", &tail)) { | |
| 2368 if (!strcmp(tail, ":jni")) { | |
| 2369 CheckJNICalls = true; | |
| 2370 } else if (is_bad_option(option, args->ignoreUnrecognized, | |
| 2371 "check")) { | |
| 2372 return JNI_EINVAL; | |
| 2373 } | |
| 2374 } else if (match_option(option, "vfprintf", &tail)) { | |
| 2375 _vfprintf_hook = CAST_TO_FN_PTR(vfprintf_hook_t, option->extraInfo); | |
| 2376 } else if (match_option(option, "exit", &tail)) { | |
| 2377 _exit_hook = CAST_TO_FN_PTR(exit_hook_t, option->extraInfo); | |
| 2378 } else if (match_option(option, "abort", &tail)) { | |
| 2379 _abort_hook = CAST_TO_FN_PTR(abort_hook_t, option->extraInfo); | |
| 2380 // -XX:+AggressiveHeap | |
| 2381 } else if (match_option(option, "-XX:+AggressiveHeap", &tail)) { | |
| 2382 | |
| 2383 // This option inspects the machine and attempts to set various | |
| 2384 // parameters to be optimal for long-running, memory allocation | |
| 2385 // intensive jobs. It is intended for machines with large | |
| 2386 // amounts of cpu and memory. | |
| 2387 | |
| 2388 // initHeapSize is needed since _initial_heap_size is 4 bytes on a 32 bit | |
| 2389 // VM, but we may not be able to represent the total physical memory | |
| 2390 // available (like having 8gb of memory on a box but using a 32bit VM). | |
| 2391 // Thus, we need to make sure we're using a julong for intermediate | |
| 2392 // calculations. | |
| 2393 julong initHeapSize; | |
| 2394 julong total_memory = os::physical_memory(); | |
| 2395 | |
| 2396 if (total_memory < (julong)256*M) { | |
| 2397 jio_fprintf(defaultStream::error_stream(), | |
| 2398 "You need at least 256mb of memory to use -XX:+AggressiveHeap\n"); | |
| 2399 vm_exit(1); | |
| 2400 } | |
| 2401 | |
| 2402 // The heap size is half of available memory, or (at most) | |
| 2403 // all of possible memory less 160mb (leaving room for the OS | |
| 2404 // when using ISM). This is the maximum; because adaptive sizing | |
| 2405 // is turned on below, the actual space used may be smaller. | |
| 2406 | |
| 2407 initHeapSize = MIN2(total_memory / (julong)2, | |
| 2408 total_memory - (julong)160*M); | |
| 2409 | |
| 2410 // Make sure that if we have a lot of memory we cap the 32 bit | |
| 2411 // process space. The 64bit VM version of this function is a nop. | |
| 2412 initHeapSize = os::allocatable_physical_memory(initHeapSize); | |
| 2413 | |
| 2414 // The perm gen is separate but contiguous with the | |
| 2415 // object heap (and is reserved with it) so subtract it | |
| 2416 // from the heap size. | |
| 2417 if (initHeapSize > MaxPermSize) { | |
| 2418 initHeapSize = initHeapSize - MaxPermSize; | |
| 2419 } else { | |
| 2420 warning("AggressiveHeap and MaxPermSize values may conflict"); | |
| 2421 } | |
| 2422 | |
| 2423 if (FLAG_IS_DEFAULT(MaxHeapSize)) { | |
| 2424 FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize); | |
| 1064 | 2425 FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize); |
| 0 | 2426 // Currently the minimum size and the initial heap sizes are the same. |
| 1064 | 2427 set_min_heap_size(initHeapSize); |
| 0 | 2428 } |
| 2429 if (FLAG_IS_DEFAULT(NewSize)) { | |
| 2430 // Make the young generation 3/8ths of the total heap. | |
| 2431 FLAG_SET_CMDLINE(uintx, NewSize, | |
| 2432 ((julong)MaxHeapSize / (julong)8) * (julong)3); | |
| 2433 FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize); | |
| 2434 } | |
| 2435 | |
| 2436 FLAG_SET_DEFAULT(UseLargePages, true); | |
| 2437 | |
| 2438 // Increase some data structure sizes for efficiency | |
| 2439 FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize); | |
| 2440 FLAG_SET_CMDLINE(bool, ResizeTLAB, false); | |
| 2441 FLAG_SET_CMDLINE(uintx, TLABSize, 256*K); | |
| 2442 | |
| 2443 // See the OldPLABSize comment below, but replace 'after promotion' | |
| 2444 // with 'after copying'. YoungPLABSize is the size of the survivor | |
| 2445 // space per-gc-thread buffers. The default is 4kw. | |
| 2446 FLAG_SET_CMDLINE(uintx, YoungPLABSize, 256*K); // Note: this is in words | |
| 2447 | |
| 2448 // OldPLABSize is the size of the buffers in the old gen that | |
| 2449 // UseParallelGC uses to promote live data that doesn't fit in the | |
| 2450 // survivor spaces. At any given time, there's one for each gc thread. | |
| 2451 // The default size is 1kw. These buffers are rarely used, since the | |
| 2452 // survivor spaces are usually big enough. For specjbb, however, there | |
| 2453 // are occasions when there's lots of live data in the young gen | |
| 2454 // and we end up promoting some of it. We don't have a definite | |
| 2455 // explanation for why bumping OldPLABSize helps, but the theory | |
| 2456 // is that a bigger PLAB results in retaining something like the | |
| 2457 // original allocation order after promotion, which improves mutator | |
| 2458 // locality. A minor effect may be that larger PLABs reduce the | |
| 2459 // number of PLAB allocation events during gc. The value of 8kw | |
| 2460 // was arrived at by experimenting with specjbb. | |
| 2461 FLAG_SET_CMDLINE(uintx, OldPLABSize, 8*K); // Note: this is in words | |
| 2462 | |
| 2463 // CompilationPolicyChoice=0 causes the server compiler to adopt | |
| 2464 // a more conservative which-method-do-I-compile policy when one | |
| 2465 // of the counters maintained by the interpreter trips. The | |
| 2466 // result is reduced startup time and improved specjbb and | |
| 2467 // alacrity performance. Zero is the default, but we set it | |
| 2468 // explicitly here in case the default changes. | |
| 2469 // See runtime/compilationPolicy.*. | |
| 2470 FLAG_SET_CMDLINE(intx, CompilationPolicyChoice, 0); | |
| 2471 | |
| 2472 // Enable parallel GC and adaptive generation sizing | |
| 2473 FLAG_SET_CMDLINE(bool, UseParallelGC, true); | |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2474 FLAG_SET_DEFAULT(ParallelGCThreads, |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
2475 Abstract_VM_Version::parallel_worker_threads()); |
| 0 | 2476 |
| 2477 // Encourage steady state memory management | |
| 2478 FLAG_SET_CMDLINE(uintx, ThresholdTolerance, 100); | |
| 2479 | |
| 2480 // This appears to improve mutator locality | |
| 2481 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); | |
| 2482 | |
| 2483 // Get around early Solaris scheduling bug | |
| 2484 // (affinity vs other jobs on system) | |
| 2485 // but disallow DR and offlining (5008695). | |
| 2486 FLAG_SET_CMDLINE(bool, BindGCTaskThreadsToCPUs, true); | |
| 2487 | |
| 2488 } else if (match_option(option, "-XX:+NeverTenure", &tail)) { | |
| 2489 // The last option must always win. | |
| 2490 FLAG_SET_CMDLINE(bool, AlwaysTenure, false); | |
| 2491 FLAG_SET_CMDLINE(bool, NeverTenure, true); | |
| 2492 } else if (match_option(option, "-XX:+AlwaysTenure", &tail)) { | |
| 2493 // The last option must always win. | |
| 2494 FLAG_SET_CMDLINE(bool, NeverTenure, false); | |
| 2495 FLAG_SET_CMDLINE(bool, AlwaysTenure, true); | |
| 2496 } else if (match_option(option, "-XX:+CMSPermGenSweepingEnabled", &tail) || | |
| 2497 match_option(option, "-XX:-CMSPermGenSweepingEnabled", &tail)) { | |
| 2498 jio_fprintf(defaultStream::error_stream(), | |
| 2499 "Please use CMSClassUnloadingEnabled in place of " | |
| 2500 "CMSPermGenSweepingEnabled in the future\n"); | |
| 2501 } else if (match_option(option, "-XX:+UseGCTimeLimit", &tail)) { | |
| 2502 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, true); | |
| 2503 jio_fprintf(defaultStream::error_stream(), | |
| 2504 "Please use -XX:+UseGCOverheadLimit in place of " | |
| 2505 "-XX:+UseGCTimeLimit in the future\n"); | |
| 2506 } else if (match_option(option, "-XX:-UseGCTimeLimit", &tail)) { | |
| 2507 FLAG_SET_CMDLINE(bool, UseGCOverheadLimit, false); | |
| 2508 jio_fprintf(defaultStream::error_stream(), | |
| 2509 "Please use -XX:-UseGCOverheadLimit in place of " | |
| 2510 "-XX:-UseGCTimeLimit in the future\n"); | |
| 2511 // The TLE options are for compatibility with 1.3 and will be | |
| 2512 // removed without notice in a future release. These options | |
| 2513 // are not to be documented. | |
| 2514 } else if (match_option(option, "-XX:MaxTLERatio=", &tail)) { | |
| 2515 // No longer used. | |
| 2516 } else if (match_option(option, "-XX:+ResizeTLE", &tail)) { | |
| 2517 FLAG_SET_CMDLINE(bool, ResizeTLAB, true); | |
| 2518 } else if (match_option(option, "-XX:-ResizeTLE", &tail)) { | |
| 2519 FLAG_SET_CMDLINE(bool, ResizeTLAB, false); | |
| 2520 } else if (match_option(option, "-XX:+PrintTLE", &tail)) { | |
| 2521 FLAG_SET_CMDLINE(bool, PrintTLAB, true); | |
| 2522 } else if (match_option(option, "-XX:-PrintTLE", &tail)) { | |
| 2523 FLAG_SET_CMDLINE(bool, PrintTLAB, false); | |
| 2524 } else if (match_option(option, "-XX:TLEFragmentationRatio=", &tail)) { | |
| 2525 // No longer used. | |
| 2526 } else if (match_option(option, "-XX:TLESize=", &tail)) { | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2527 julong long_tlab_size = 0; |
| 0 | 2528 ArgsRange errcode = parse_memory_size(tail, &long_tlab_size, 1); |
| 2529 if (errcode != arg_in_range) { | |
| 2530 jio_fprintf(defaultStream::error_stream(), | |
| 2531 "Invalid TLAB size: %s\n", option->optionString); | |
| 2532 describe_range_error(errcode); | |
| 2533 return JNI_EINVAL; | |
| 2534 } | |
| 2535 FLAG_SET_CMDLINE(uintx, TLABSize, long_tlab_size); | |
| 2536 } else if (match_option(option, "-XX:TLEThreadRatio=", &tail)) { | |
| 2537 // No longer used. | |
| 2538 } else if (match_option(option, "-XX:+UseTLE", &tail)) { | |
| 2539 FLAG_SET_CMDLINE(bool, UseTLAB, true); | |
| 2540 } else if (match_option(option, "-XX:-UseTLE", &tail)) { | |
| 2541 FLAG_SET_CMDLINE(bool, UseTLAB, false); | |
| 2542 SOLARIS_ONLY( | |
| 2543 } else if (match_option(option, "-XX:+UsePermISM", &tail)) { | |
| 2544 warning("-XX:+UsePermISM is obsolete."); | |
| 2545 FLAG_SET_CMDLINE(bool, UseISM, true); | |
| 2546 } else if (match_option(option, "-XX:-UsePermISM", &tail)) { | |
| 2547 FLAG_SET_CMDLINE(bool, UseISM, false); | |
| 2548 ) | |
| 2549 } else if (match_option(option, "-XX:+DisplayVMOutputToStderr", &tail)) { | |
| 2550 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, false); | |
| 2551 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, true); | |
| 2552 } else if (match_option(option, "-XX:+DisplayVMOutputToStdout", &tail)) { | |
| 2553 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, false); | |
| 2554 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, true); | |
| 2555 } else if (match_option(option, "-XX:+ExtendedDTraceProbes", &tail)) { | |
| 2556 #ifdef SOLARIS | |
| 2557 FLAG_SET_CMDLINE(bool, ExtendedDTraceProbes, true); | |
| 2558 FLAG_SET_CMDLINE(bool, DTraceMethodProbes, true); | |
| 2559 FLAG_SET_CMDLINE(bool, DTraceAllocProbes, true); | |
| 2560 FLAG_SET_CMDLINE(bool, DTraceMonitorProbes, true); | |
| 2561 #else // ndef SOLARIS | |
| 2562 jio_fprintf(defaultStream::error_stream(), | |
| 2563 "ExtendedDTraceProbes flag is only applicable on Solaris\n"); | |
| 2564 return JNI_EINVAL; | |
| 2565 #endif // ndef SOLARIS | |
| 2566 #ifdef ASSERT | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2567 } else if (match_option(option, "-XX:+FullGCALot", &tail)) { |
| 0 | 2568 FLAG_SET_CMDLINE(bool, FullGCALot, true); |
| 2569 // disable scavenge before parallel mark-compact | |
| 2570 FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); | |
| 2571 #endif | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2572 } else if (match_option(option, "-XX:CMSParPromoteBlocksToClaim=", &tail)) { |
| 0 | 2573 julong cms_blocks_to_claim = (julong)atol(tail); |
| 2574 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim); | |
| 2575 jio_fprintf(defaultStream::error_stream(), | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2576 "Please use -XX:OldPLABSize in place of " |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2577 "-XX:CMSParPromoteBlocksToClaim in the future\n"); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2578 } else if (match_option(option, "-XX:ParCMSPromoteBlocksToClaim=", &tail)) { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2579 julong cms_blocks_to_claim = (julong)atol(tail); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2580 FLAG_SET_CMDLINE(uintx, CMSParPromoteBlocksToClaim, cms_blocks_to_claim); |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2581 jio_fprintf(defaultStream::error_stream(), |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2582 "Please use -XX:OldPLABSize in place of " |
| 0 | 2583 "-XX:ParCMSPromoteBlocksToClaim in the future\n"); |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2584 } else if (match_option(option, "-XX:ParallelGCOldGenAllocBufferSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2585 julong old_plab_size = 0; |
| 0 | 2586 ArgsRange errcode = parse_memory_size(tail, &old_plab_size, 1); |
| 2587 if (errcode != arg_in_range) { | |
| 2588 jio_fprintf(defaultStream::error_stream(), | |
| 2589 "Invalid old PLAB size: %s\n", option->optionString); | |
| 2590 describe_range_error(errcode); | |
| 2591 return JNI_EINVAL; | |
| 2592 } | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2593 FLAG_SET_CMDLINE(uintx, OldPLABSize, old_plab_size); |
| 0 | 2594 jio_fprintf(defaultStream::error_stream(), |
| 2595 "Please use -XX:OldPLABSize in place of " | |
| 2596 "-XX:ParallelGCOldGenAllocBufferSize in the future\n"); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2597 } else if (match_option(option, "-XX:ParallelGCToSpaceAllocBufferSize=", &tail)) { |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2598 julong young_plab_size = 0; |
| 0 | 2599 ArgsRange errcode = parse_memory_size(tail, &young_plab_size, 1); |
| 2600 if (errcode != arg_in_range) { | |
| 2601 jio_fprintf(defaultStream::error_stream(), | |
| 2602 "Invalid young PLAB size: %s\n", option->optionString); | |
| 2603 describe_range_error(errcode); | |
| 2604 return JNI_EINVAL; | |
| 2605 } | |
|
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
483
diff
changeset
|
2606 FLAG_SET_CMDLINE(uintx, YoungPLABSize, young_plab_size); |
| 0 | 2607 jio_fprintf(defaultStream::error_stream(), |
| 2608 "Please use -XX:YoungPLABSize in place of " | |
| 2609 "-XX:ParallelGCToSpaceAllocBufferSize in the future\n"); | |
| 1284 | 2610 } else if (match_option(option, "-XX:CMSMarkStackSize=", &tail) || |
| 2611 match_option(option, "-XX:G1MarkStackSize=", &tail)) { | |
| 2612 julong stack_size = 0; | |
| 2613 ArgsRange errcode = parse_memory_size(tail, &stack_size, 1); | |
| 2614 if (errcode != arg_in_range) { | |
| 2615 jio_fprintf(defaultStream::error_stream(), | |
| 2616 "Invalid mark stack size: %s\n", option->optionString); | |
| 2617 describe_range_error(errcode); | |
| 2618 return JNI_EINVAL; | |
| 2619 } | |
| 2620 FLAG_SET_CMDLINE(uintx, MarkStackSize, stack_size); | |
| 2621 } else if (match_option(option, "-XX:CMSMarkStackSizeMax=", &tail)) { | |
| 2622 julong max_stack_size = 0; | |
| 2623 ArgsRange errcode = parse_memory_size(tail, &max_stack_size, 1); | |
| 2624 if (errcode != arg_in_range) { | |
| 2625 jio_fprintf(defaultStream::error_stream(), | |
| 2626 "Invalid maximum mark stack size: %s\n", | |
| 2627 option->optionString); | |
| 2628 describe_range_error(errcode); | |
| 2629 return JNI_EINVAL; | |
| 2630 } | |
| 2631 FLAG_SET_CMDLINE(uintx, MarkStackSizeMax, max_stack_size); | |
| 2632 } else if (match_option(option, "-XX:ParallelMarkingThreads=", &tail) || | |
| 2633 match_option(option, "-XX:ParallelCMSThreads=", &tail)) { | |
| 2634 uintx conc_threads = 0; | |
| 2635 if (!parse_uintx(tail, &conc_threads, 1)) { | |
| 2636 jio_fprintf(defaultStream::error_stream(), | |
| 2637 "Invalid concurrent threads: %s\n", option->optionString); | |
| 2638 return JNI_EINVAL; | |
| 2639 } | |
| 2640 FLAG_SET_CMDLINE(uintx, ConcGCThreads, conc_threads); | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
2641 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx |
| 0 | 2642 // Skip -XX:Flags= since that case has already been handled |
| 2643 if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) { | |
| 2644 if (!process_argument(tail, args->ignoreUnrecognized, origin)) { | |
| 2645 return JNI_EINVAL; | |
| 2646 } | |
| 2647 } | |
| 2648 // Unknown option | |
| 2649 } else if (is_bad_option(option, args->ignoreUnrecognized)) { | |
| 2650 return JNI_ERR; | |
| 2651 } | |
| 2652 } | |
|
449
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
2653 // 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
|
2654 // when working with older JDKs. |
|
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
2655 if (JDK_Version::current().compare_major(6) <= 0 && |
|
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
2656 FLAG_IS_DEFAULT(UseVMInterruptibleIO)) { |
|
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
2657 FLAG_SET_DEFAULT(UseVMInterruptibleIO, true); |
|
171e581e8161
6554406: Change switch UseVMInterruptibleIO default to false (sol)
xlu
parents:
420
diff
changeset
|
2658 } |
|
1679
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
2659 #ifdef LINUX |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
2660 if (JDK_Version::current().compare_major(6) <= 0 && |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
2661 FLAG_IS_DEFAULT(UseLinuxPosixThreadCPUClocks)) { |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
2662 FLAG_SET_DEFAULT(UseLinuxPosixThreadCPUClocks, false); |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
2663 } |
|
3d90023429ec
6888526: Linux getCurrentThreadCpuTime is drastically slower than Windows
aph
parents:
1628
diff
changeset
|
2664 #endif // LINUX |
| 0 | 2665 return JNI_OK; |
| 2666 } | |
| 2667 | |
| 2668 jint Arguments::finalize_vm_init_args(SysClassPath* scp_p, bool scp_assembly_required) { | |
| 2669 // This must be done after all -D arguments have been processed. | |
| 2670 scp_p->expand_endorsed(); | |
| 2671 | |
| 2672 if (scp_assembly_required || scp_p->get_endorsed() != NULL) { | |
| 2673 // Assemble the bootclasspath elements into the final path. | |
| 2674 Arguments::set_sysclasspath(scp_p->combined_path()); | |
| 2675 } | |
| 2676 | |
| 2677 // This must be done after all arguments have been processed. | |
| 2678 // java_compiler() true means set to "NONE" or empty. | |
| 2679 if (java_compiler() && !xdebug_mode()) { | |
| 2680 // For backwards compatibility, we switch to interpreted mode if | |
| 2681 // -Djava.compiler="NONE" or "" is specified AND "-Xdebug" was | |
| 2682 // not specified. | |
| 2683 set_mode_flags(_int); | |
| 2684 } | |
| 2685 if (CompileThreshold == 0) { | |
| 2686 set_mode_flags(_int); | |
| 2687 } | |
| 2688 | |
| 2689 #ifndef COMPILER2 | |
| 2690 // Don't degrade server performance for footprint | |
| 2691 if (FLAG_IS_DEFAULT(UseLargePages) && | |
| 2692 MaxHeapSize < LargePageHeapSizeThreshold) { | |
| 2693 // No need for large granularity pages w/small heaps. | |
| 2694 // Note that large pages are enabled/disabled for both the | |
| 2695 // Java heap and the code cache. | |
| 2696 FLAG_SET_DEFAULT(UseLargePages, false); | |
| 2697 SOLARIS_ONLY(FLAG_SET_DEFAULT(UseMPSS, false)); | |
| 2698 SOLARIS_ONLY(FLAG_SET_DEFAULT(UseISM, false)); | |
| 2699 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
2700 |
|
1251
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1188
diff
changeset
|
2701 // Tiered compilation is undefined with C1. |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1188
diff
changeset
|
2702 TieredCompilation = false; |
| 0 | 2703 #else |
| 2704 if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) { | |
| 2705 FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1); | |
| 2706 } | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
2707 // Temporary disable bulk zeroing reduction with G1. See CR 6627983. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
2708 if (UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
2709 FLAG_SET_DEFAULT(ReduceBulkZeroing, false); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
2710 } |
| 0 | 2711 #endif |
| 2712 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2713 // 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
|
2714 // to be true unless the property has already been set. |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2715 // 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
|
2716 if (os::is_headless_jre()) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2717 const char* headless = Arguments::get_property("java.awt.headless"); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2718 if (headless == NULL) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2719 char envbuffer[128]; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2720 if (!os::getenv("JAVA_AWT_HEADLESS", envbuffer, sizeof(envbuffer))) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2721 if (!add_property("java.awt.headless=true")) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2722 return JNI_ENOMEM; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2723 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2724 } else { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2725 char buffer[256]; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2726 strcpy(buffer, "java.awt.headless="); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2727 strcat(buffer, envbuffer); |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2728 if (!add_property(buffer)) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2729 return JNI_ENOMEM; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2730 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2731 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2732 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2733 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
2734 |
| 0 | 2735 if (!check_vm_args_consistency()) { |
| 2736 return JNI_ERR; | |
| 2737 } | |
| 2738 | |
| 2739 return JNI_OK; | |
| 2740 } | |
| 2741 | |
| 2742 jint Arguments::parse_java_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p) { | |
| 2743 return parse_options_environment_variable("_JAVA_OPTIONS", scp_p, | |
| 2744 scp_assembly_required_p); | |
| 2745 } | |
| 2746 | |
| 2747 jint Arguments::parse_java_tool_options_environment_variable(SysClassPath* scp_p, bool* scp_assembly_required_p) { | |
| 2748 return parse_options_environment_variable("JAVA_TOOL_OPTIONS", scp_p, | |
| 2749 scp_assembly_required_p); | |
| 2750 } | |
| 2751 | |
| 2752 jint Arguments::parse_options_environment_variable(const char* name, SysClassPath* scp_p, bool* scp_assembly_required_p) { | |
| 2753 const int N_MAX_OPTIONS = 64; | |
| 2754 const int OPTION_BUFFER_SIZE = 1024; | |
| 2755 char buffer[OPTION_BUFFER_SIZE]; | |
| 2756 | |
| 2757 // The variable will be ignored if it exceeds the length of the buffer. | |
| 2758 // Don't check this variable if user has special privileges | |
| 2759 // (e.g. unix su command). | |
| 2760 if (os::getenv(name, buffer, sizeof(buffer)) && | |
| 2761 !os::have_special_privileges()) { | |
| 2762 JavaVMOption options[N_MAX_OPTIONS]; // Construct option array | |
| 2763 jio_fprintf(defaultStream::error_stream(), | |
| 2764 "Picked up %s: %s\n", name, buffer); | |
| 2765 char* rd = buffer; // pointer to the input string (rd) | |
| 2766 int i; | |
| 2767 for (i = 0; i < N_MAX_OPTIONS;) { // repeat for all options in the input string | |
| 2768 while (isspace(*rd)) rd++; // skip whitespace | |
| 2769 if (*rd == 0) break; // we re done when the input string is read completely | |
| 2770 | |
| 2771 // The output, option string, overwrites the input string. | |
| 2772 // Because of quoting, the pointer to the option string (wrt) may lag the pointer to | |
| 2773 // input string (rd). | |
| 2774 char* wrt = rd; | |
| 2775 | |
| 2776 options[i++].optionString = wrt; // Fill in option | |
| 2777 while (*rd != 0 && !isspace(*rd)) { // unquoted strings terminate with a space or NULL | |
| 2778 if (*rd == '\'' || *rd == '"') { // handle a quoted string | |
| 2779 int quote = *rd; // matching quote to look for | |
| 2780 rd++; // don't copy open quote | |
| 2781 while (*rd != quote) { // include everything (even spaces) up until quote | |
| 2782 if (*rd == 0) { // string termination means unmatched string | |
| 2783 jio_fprintf(defaultStream::error_stream(), | |
| 2784 "Unmatched quote in %s\n", name); | |
| 2785 return JNI_ERR; | |
| 2786 } | |
| 2787 *wrt++ = *rd++; // copy to option string | |
| 2788 } | |
| 2789 rd++; // don't copy close quote | |
| 2790 } else { | |
| 2791 *wrt++ = *rd++; // copy to option string | |
| 2792 } | |
| 2793 } | |
| 2794 // Need to check if we're done before writing a NULL, | |
| 2795 // because the write could be to the byte that rd is pointing to. | |
| 2796 if (*rd++ == 0) { | |
| 2797 *wrt = 0; | |
| 2798 break; | |
| 2799 } | |
| 2800 *wrt = 0; // Zero terminate option | |
| 2801 } | |
| 2802 // Construct JavaVMInitArgs structure and parse as if it was part of the command line | |
| 2803 JavaVMInitArgs vm_args; | |
| 2804 vm_args.version = JNI_VERSION_1_2; | |
| 2805 vm_args.options = options; | |
| 2806 vm_args.nOptions = i; | |
| 564 | 2807 vm_args.ignoreUnrecognized = IgnoreUnrecognizedVMOptions; |
| 0 | 2808 |
| 2809 if (PrintVMOptions) { | |
| 2810 const char* tail; | |
| 2811 for (int i = 0; i < vm_args.nOptions; i++) { | |
| 2812 const JavaVMOption *option = vm_args.options + i; | |
| 2813 if (match_option(option, "-XX:", &tail)) { | |
| 2814 logOption(tail); | |
| 2815 } | |
| 2816 } | |
| 2817 } | |
| 2818 | |
| 2819 return(parse_each_vm_init_arg(&vm_args, scp_p, scp_assembly_required_p, ENVIRON_VAR)); | |
| 2820 } | |
| 2821 return JNI_OK; | |
| 2822 } | |
| 2823 | |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2824 void Arguments::set_shared_spaces_flags() { |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2825 // Check whether class data sharing settings conflict with GC, compressed oops |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2826 // or page size, and fix them up. Explicit sharing options override other |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2827 // settings. |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2828 const bool cannot_share = UseConcMarkSweepGC || CMSIncrementalMode || |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2829 UseG1GC || UseParNewGC || UseParallelGC || UseParallelOldGC || |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2830 UseCompressedOops || UseLargePages && FLAG_IS_CMDLINE(UseLargePages); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2831 const bool must_share = DumpSharedSpaces || RequireSharedSpaces; |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2832 const bool might_share = must_share || UseSharedSpaces; |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2833 if (cannot_share) { |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2834 if (must_share) { |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2835 warning("selecting serial gc and disabling large pages %s" |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2836 "because of %s", "" LP64_ONLY("and compressed oops "), |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2837 DumpSharedSpaces ? "-Xshare:dump" : "-Xshare:on"); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2838 force_serial_gc(); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2839 FLAG_SET_CMDLINE(bool, UseLargePages, false); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2840 LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedOops, false)); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2841 } else { |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2842 if (UseSharedSpaces && Verbose) { |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2843 warning("turning off use of shared archive because of " |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2844 "choice of garbage collector or large pages"); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2845 } |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2846 no_shared_spaces(); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2847 } |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2848 } else if (UseLargePages && might_share) { |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2849 // Disable large pages to allow shared spaces. This is sub-optimal, since |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2850 // there may not even be a shared archive to use. |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2851 FLAG_SET_DEFAULT(UseLargePages, false); |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2852 } |
|
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
2853 } |
|
1891
9de67bf4244d
6996136: VM crash in src/share/vm/runtime/virtualspace.cpp:424
iveresov
parents:
1890
diff
changeset
|
2854 |
| 0 | 2855 // Parse entry point called from JNI_CreateJavaVM |
| 2856 | |
| 2857 jint Arguments::parse(const JavaVMInitArgs* args) { | |
| 2858 | |
| 2859 // Sharing support | |
| 2860 // Construct the path to the archive | |
| 2861 char jvm_path[JVM_MAXPATHLEN]; | |
| 2862 os::jvm_path(jvm_path, sizeof(jvm_path)); | |
| 2863 #ifdef TIERED | |
| 2864 if (strstr(jvm_path, "client") != NULL) { | |
| 2865 force_client_mode = true; | |
| 2866 } | |
| 2867 #endif // TIERED | |
| 2868 char *end = strrchr(jvm_path, *os::file_separator()); | |
| 2869 if (end != NULL) *end = '\0'; | |
| 2870 char *shared_archive_path = NEW_C_HEAP_ARRAY(char, strlen(jvm_path) + | |
| 2871 strlen(os::file_separator()) + 20); | |
| 2872 if (shared_archive_path == NULL) return JNI_ENOMEM; | |
| 2873 strcpy(shared_archive_path, jvm_path); | |
| 2874 strcat(shared_archive_path, os::file_separator()); | |
| 2875 strcat(shared_archive_path, "classes"); | |
| 2876 DEBUG_ONLY(strcat(shared_archive_path, "_g");) | |
| 2877 strcat(shared_archive_path, ".jsa"); | |
| 2878 SharedArchivePath = shared_archive_path; | |
| 2879 | |
| 2880 // Remaining part of option string | |
| 2881 const char* tail; | |
| 2882 | |
| 2883 // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed. | |
| 2884 bool settings_file_specified = false; | |
| 564 | 2885 const char* flags_file; |
| 0 | 2886 int index; |
| 2887 for (index = 0; index < args->nOptions; index++) { | |
| 2888 const JavaVMOption *option = args->options + index; | |
| 2889 if (match_option(option, "-XX:Flags=", &tail)) { | |
| 564 | 2890 flags_file = tail; |
| 0 | 2891 settings_file_specified = true; |
| 2892 } | |
| 2893 if (match_option(option, "-XX:+PrintVMOptions", &tail)) { | |
| 2894 PrintVMOptions = true; | |
| 2895 } | |
|
253
b0fe4deeb9fb
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
196
diff
changeset
|
2896 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
|
2897 PrintVMOptions = false; |
|
b0fe4deeb9fb
6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents:
196
diff
changeset
|
2898 } |
| 564 | 2899 if (match_option(option, "-XX:+IgnoreUnrecognizedVMOptions", &tail)) { |
| 2900 IgnoreUnrecognizedVMOptions = true; | |
| 2901 } | |
| 2902 if (match_option(option, "-XX:-IgnoreUnrecognizedVMOptions", &tail)) { | |
| 2903 IgnoreUnrecognizedVMOptions = false; | |
| 2904 } | |
| 1150 | 2905 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) { |
| 2906 CommandLineFlags::printFlags(); | |
| 2907 vm_exit(0); | |
| 2908 } | |
|
1768
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2909 |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2910 #ifndef PRODUCT |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2911 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) { |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2912 CommandLineFlags::printFlags(true); |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2913 vm_exit(0); |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2914 } |
|
6ee479178066
6979444: add command line option to print command line flags descriptions
ikrylov
parents:
1745
diff
changeset
|
2915 #endif |
| 564 | 2916 } |
| 2917 | |
| 2918 if (IgnoreUnrecognizedVMOptions) { | |
| 2919 // uncast const to modify the flag args->ignoreUnrecognized | |
| 2920 *(jboolean*)(&args->ignoreUnrecognized) = true; | |
| 2921 } | |
| 2922 | |
| 2923 // Parse specified settings file | |
| 2924 if (settings_file_specified) { | |
| 2925 if (!process_settings_file(flags_file, true, args->ignoreUnrecognized)) { | |
| 2926 return JNI_EINVAL; | |
| 2927 } | |
| 0 | 2928 } |
| 2929 | |
| 2930 // Parse default .hotspotrc settings file | |
| 2931 if (!settings_file_specified) { | |
| 2932 if (!process_settings_file(".hotspotrc", false, args->ignoreUnrecognized)) { | |
| 2933 return JNI_EINVAL; | |
| 2934 } | |
| 2935 } | |
| 2936 | |
| 2937 if (PrintVMOptions) { | |
| 2938 for (index = 0; index < args->nOptions; index++) { | |
| 2939 const JavaVMOption *option = args->options + index; | |
| 2940 if (match_option(option, "-XX:", &tail)) { | |
| 2941 logOption(tail); | |
| 2942 } | |
| 2943 } | |
| 2944 } | |
| 2945 | |
| 2946 // Parse JavaVMInitArgs structure passed in, as well as JAVA_TOOL_OPTIONS and _JAVA_OPTIONS | |
| 2947 jint result = parse_vm_init_args(args); | |
| 2948 if (result != JNI_OK) { | |
| 2949 return result; | |
| 2950 } | |
| 2951 | |
| 2952 #ifndef PRODUCT | |
| 2953 if (TraceBytecodesAt != 0) { | |
| 2954 TraceBytecodes = true; | |
| 2955 } | |
| 2956 if (CountCompiledCalls) { | |
| 2957 if (UseCounterDecay) { | |
| 2958 warning("UseCounterDecay disabled because CountCalls is set"); | |
| 2959 UseCounterDecay = false; | |
| 2960 } | |
| 2961 } | |
| 2962 #endif // PRODUCT | |
| 2963 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
712
diff
changeset
|
2964 if (EnableInvokeDynamic && !EnableMethodHandles) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
712
diff
changeset
|
2965 if (!FLAG_IS_DEFAULT(EnableMethodHandles)) { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2966 warning("forcing EnableMethodHandles true because EnableInvokeDynamic is true"); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
712
diff
changeset
|
2967 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
712
diff
changeset
|
2968 EnableMethodHandles = true; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
712
diff
changeset
|
2969 } |
| 710 | 2970 if (EnableMethodHandles && !AnonymousClasses) { |
| 2971 if (!FLAG_IS_DEFAULT(AnonymousClasses)) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2972 warning("forcing AnonymousClasses true because EnableMethodHandles is true"); |
| 710 | 2973 } |
| 2974 AnonymousClasses = true; | |
| 2975 } | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2976 if ((EnableMethodHandles || AnonymousClasses) && ScavengeRootsInCode == 0) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2977 if (!FLAG_IS_DEFAULT(ScavengeRootsInCode)) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2978 warning("forcing ScavengeRootsInCode non-zero because EnableMethodHandles or AnonymousClasses is true"); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2979 } |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2980 ScavengeRootsInCode = 1; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
932
diff
changeset
|
2981 } |
| 710 | 2982 |
| 0 | 2983 if (PrintGCDetails) { |
| 2984 // Turn on -verbose:gc options as well | |
| 2985 PrintGC = true; | |
| 2986 } | |
| 2987 | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1506
diff
changeset
|
2988 // 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
|
2989 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
|
2990 |
| 0 | 2991 #ifdef SERIALGC |
| 1064 | 2992 force_serial_gc(); |
| 0 | 2993 #endif // SERIALGC |
| 2994 #ifdef KERNEL | |
| 2995 no_shared_spaces(); | |
| 2996 #endif // KERNEL | |
| 2997 | |
| 2998 // Set flags based on ergonomics. | |
| 2999 set_ergonomics_flags(); | |
| 3000 | |
|
2362
a2c2eac1ca62
7018056: large pages not always enabled by default
jcoomes
parents:
2302
diff
changeset
|
3001 set_shared_spaces_flags(); |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1131
diff
changeset
|
3002 |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3003 // Check the GC selections again. |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3004 if (!check_gc_consistency()) { |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3005 return JNI_EINVAL; |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3006 } |
|
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3007 |
| 1783 | 3008 if (TieredCompilation) { |
| 3009 set_tiered_flags(); | |
| 3010 } else { | |
| 3011 // Check if the policy is valid. Policies 0 and 1 are valid for non-tiered setup. | |
| 3012 if (CompilationPolicyChoice >= 2) { | |
| 3013 vm_exit_during_initialization( | |
| 3014 "Incompatible compilation policy selected", NULL); | |
| 3015 } | |
| 3016 } | |
| 3017 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3018 #ifndef KERNEL |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3019 // Set heap size based on available physical memory |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3020 set_heap_size(); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3021 // Set per-collector flags |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3022 if (UseParallelGC || UseParallelOldGC) { |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3023 set_parallel_gc_flags(); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3024 } 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
|
3025 set_cms_and_parnew_gc_flags(); |
|
2368
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3026 } 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
|
3027 set_parnew_gc_flags(); |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3028 } else if (UseG1GC) { |
|
dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
ysr
parents:
2366
diff
changeset
|
3029 set_g1_gc_flags(); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
3030 } |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
1074
diff
changeset
|
3031 #endif // KERNEL |
|
10
28372612af5e
6362677: Change parallel GC collector default number of parallel GC threads.
jmasa
parents:
0
diff
changeset
|
3032 |
| 0 | 3033 #ifdef SERIALGC |
| 3034 assert(verify_serial_gc_flags(), "SerialGC unset"); | |
| 3035 #endif // SERIALGC | |
| 3036 | |
| 3037 // Set bytecode rewriting flags | |
| 3038 set_bytecode_flags(); | |
| 3039 | |
| 3040 // Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled. | |
| 3041 set_aggressive_opts_flags(); | |
| 3042 | |
|
2239
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3043 // Turn off biased locking for locking debug mode flags, |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3044 // 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
|
3045 // biased locking. |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3046 if (!UseFastLocking || UseHeavyMonitors) { |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3047 if (!FLAG_IS_DEFAULT(UseBiasedLocking) && UseBiasedLocking) { |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3048 // 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
|
3049 // can't enable biased locking here |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3050 warning("Biased Locking is not supported with locking debug flags" |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3051 "; ignoring UseBiasedLocking flag." ); |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3052 } |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3053 UseBiasedLocking = false; |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3054 } |
|
c08677f98289
6840152: JVM crashes when heavyweight monitors are used
coleenp
parents:
2176
diff
changeset
|
3055 |
| 0 | 3056 #ifdef CC_INTERP |
| 1131 | 3057 // Clear flags not supported by the C++ interpreter |
| 3058 FLAG_SET_DEFAULT(ProfileInterpreter, false); | |
| 0 | 3059 FLAG_SET_DEFAULT(UseBiasedLocking, false); |
| 1131 | 3060 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false)); |
| 3061 #endif // CC_INTERP | |
| 3062 | |
|
420
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3063 #ifdef COMPILER2 |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3064 if (!UseBiasedLocking || EmitSync != 0) { |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3065 UseOptoBiasInlining = false; |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3066 } |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3067 #endif |
|
a1980da045cc
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
416
diff
changeset
|
3068 |
|
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3069 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) { |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3070 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
|
3071 DebugNonSafepoints = true; |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3072 } |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1150
diff
changeset
|
3073 |
|
1188
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3074 #ifndef PRODUCT |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3075 if (CompileTheWorld) { |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3076 // 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
|
3077 if (FLAG_IS_DEFAULT(NmethodSweepFraction)) { |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3078 NmethodSweepFraction = 1; |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3079 } |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3080 } |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3081 #endif |
|
99af867dfa05
6919886: Sweep CodeCache more aggressively to reduce its usage for CompileTheWorld
kvn
parents:
1161
diff
changeset
|
3082 |
| 0 | 3083 if (PrintCommandLineFlags) { |
| 3084 CommandLineFlags::printSetFlags(); | |
| 3085 } | |
| 3086 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3087 // Apply CPU specific policy for the BiasedLocking |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3088 if (UseBiasedLocking) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3089 if (!VM_Version::use_biased_locking() && |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3090 !(FLAG_IS_CMDLINE(UseBiasedLocking))) { |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3091 UseBiasedLocking = false; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3092 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3093 } |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1679
diff
changeset
|
3094 |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3095 // 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
|
3096 // 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
|
3097 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
|
3098 bool set = false; |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3099 CommandLineFlags::wasSetOnCmdline("PauseAtExit", &set); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3100 if (!set) { |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3101 FLAG_SET_DEFAULT(PauseAtExit, true); |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3102 } |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3103 } |
|
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2243
diff
changeset
|
3104 |
| 0 | 3105 return JNI_OK; |
| 3106 } | |
| 3107 | |
| 3108 int Arguments::PropertyList_count(SystemProperty* pl) { | |
| 3109 int count = 0; | |
| 3110 while(pl != NULL) { | |
| 3111 count++; | |
| 3112 pl = pl->next(); | |
| 3113 } | |
| 3114 return count; | |
| 3115 } | |
| 3116 | |
| 3117 const char* Arguments::PropertyList_get_value(SystemProperty *pl, const char* key) { | |
| 3118 assert(key != NULL, "just checking"); | |
| 3119 SystemProperty* prop; | |
| 3120 for (prop = pl; prop != NULL; prop = prop->next()) { | |
| 3121 if (strcmp(key, prop->key()) == 0) return prop->value(); | |
| 3122 } | |
| 3123 return NULL; | |
| 3124 } | |
| 3125 | |
| 3126 const char* Arguments::PropertyList_get_key_at(SystemProperty *pl, int index) { | |
| 3127 int count = 0; | |
| 3128 const char* ret_val = NULL; | |
| 3129 | |
| 3130 while(pl != NULL) { | |
| 3131 if(count >= index) { | |
| 3132 ret_val = pl->key(); | |
| 3133 break; | |
| 3134 } | |
| 3135 count++; | |
| 3136 pl = pl->next(); | |
| 3137 } | |
| 3138 | |
| 3139 return ret_val; | |
| 3140 } | |
| 3141 | |
| 3142 char* Arguments::PropertyList_get_value_at(SystemProperty* pl, int index) { | |
| 3143 int count = 0; | |
| 3144 char* ret_val = NULL; | |
| 3145 | |
| 3146 while(pl != NULL) { | |
| 3147 if(count >= index) { | |
| 3148 ret_val = pl->value(); | |
| 3149 break; | |
| 3150 } | |
| 3151 count++; | |
| 3152 pl = pl->next(); | |
| 3153 } | |
| 3154 | |
| 3155 return ret_val; | |
| 3156 } | |
| 3157 | |
| 3158 void Arguments::PropertyList_add(SystemProperty** plist, SystemProperty *new_p) { | |
| 3159 SystemProperty* p = *plist; | |
| 3160 if (p == NULL) { | |
| 3161 *plist = new_p; | |
| 3162 } else { | |
| 3163 while (p->next() != NULL) { | |
| 3164 p = p->next(); | |
| 3165 } | |
| 3166 p->set_next(new_p); | |
| 3167 } | |
| 3168 } | |
| 3169 | |
| 3170 void Arguments::PropertyList_add(SystemProperty** plist, const char* k, char* v) { | |
| 3171 if (plist == NULL) | |
| 3172 return; | |
| 3173 | |
| 3174 SystemProperty* new_p = new SystemProperty(k, v, true); | |
| 3175 PropertyList_add(plist, new_p); | |
| 3176 } | |
| 3177 | |
| 3178 // This add maintains unique property key in the list. | |
| 691 | 3179 void Arguments::PropertyList_unique_add(SystemProperty** plist, const char* k, char* v, jboolean append) { |
| 0 | 3180 if (plist == NULL) |
| 3181 return; | |
| 3182 | |
| 3183 // If property key exist then update with new value. | |
| 3184 SystemProperty* prop; | |
| 3185 for (prop = *plist; prop != NULL; prop = prop->next()) { | |
| 3186 if (strcmp(k, prop->key()) == 0) { | |
| 691 | 3187 if (append) { |
| 3188 prop->append_value(v); | |
| 3189 } else { | |
| 3190 prop->set_value(v); | |
| 3191 } | |
| 0 | 3192 return; |
| 3193 } | |
| 3194 } | |
| 3195 | |
| 3196 PropertyList_add(plist, k, v); | |
| 3197 } | |
| 3198 | |
| 3199 #ifdef KERNEL | |
| 3200 char *Arguments::get_kernel_properties() { | |
| 3201 // Find properties starting with kernel and append them to string | |
| 3202 // We need to find out how long they are first because the URL's that they | |
| 3203 // might point to could get long. | |
| 3204 int length = 0; | |
| 3205 SystemProperty* prop; | |
| 3206 for (prop = _system_properties; prop != NULL; prop = prop->next()) { | |
| 3207 if (strncmp(prop->key(), "kernel.", 7 ) == 0) { | |
| 3208 length += (strlen(prop->key()) + strlen(prop->value()) + 5); // "-D =" | |
| 3209 } | |
| 3210 } | |
| 3211 // Add one for null terminator. | |
| 3212 char *props = AllocateHeap(length + 1, "get_kernel_properties"); | |
| 3213 if (length != 0) { | |
| 3214 int pos = 0; | |
| 3215 for (prop = _system_properties; prop != NULL; prop = prop->next()) { | |
| 3216 if (strncmp(prop->key(), "kernel.", 7 ) == 0) { | |
| 3217 jio_snprintf(&props[pos], length-pos, | |
| 3218 "-D%s=%s ", prop->key(), prop->value()); | |
| 3219 pos = strlen(props); | |
| 3220 } | |
| 3221 } | |
| 3222 } | |
| 3223 // null terminate props in case of null | |
| 3224 props[length] = '\0'; | |
| 3225 return props; | |
| 3226 } | |
| 3227 #endif // KERNEL | |
| 3228 | |
| 3229 // Copies src into buf, replacing "%%" with "%" and "%p" with pid | |
| 3230 // Returns true if all of the source pointed by src has been copied over to | |
| 3231 // the destination buffer pointed by buf. Otherwise, returns false. | |
| 3232 // Notes: | |
| 3233 // 1. If the length (buflen) of the destination buffer excluding the | |
| 3234 // NULL terminator character is not long enough for holding the expanded | |
| 3235 // pid characters, it also returns false instead of returning the partially | |
| 3236 // expanded one. | |
| 3237 // 2. The passed in "buflen" should be large enough to hold the null terminator. | |
| 3238 bool Arguments::copy_expand_pid(const char* src, size_t srclen, | |
| 3239 char* buf, size_t buflen) { | |
| 3240 const char* p = src; | |
| 3241 char* b = buf; | |
| 3242 const char* src_end = &src[srclen]; | |
| 3243 char* buf_end = &buf[buflen - 1]; | |
| 3244 | |
| 3245 while (p < src_end && b < buf_end) { | |
| 3246 if (*p == '%') { | |
| 3247 switch (*(++p)) { | |
| 3248 case '%': // "%%" ==> "%" | |
| 3249 *b++ = *p++; | |
| 3250 break; | |
| 3251 case 'p': { // "%p" ==> current process id | |
| 3252 // buf_end points to the character before the last character so | |
| 3253 // that we could write '\0' to the end of the buffer. | |
| 3254 size_t buf_sz = buf_end - b + 1; | |
| 3255 int ret = jio_snprintf(b, buf_sz, "%d", os::current_process_id()); | |
| 3256 | |
| 3257 // if jio_snprintf fails or the buffer is not long enough to hold | |
| 3258 // the expanded pid, returns false. | |
| 3259 if (ret < 0 || ret >= (int)buf_sz) { | |
| 3260 return false; | |
| 3261 } else { | |
| 3262 b += ret; | |
| 3263 assert(*b == '\0', "fail in copy_expand_pid"); | |
| 3264 if (p == src_end && b == buf_end + 1) { | |
| 3265 // reach the end of the buffer. | |
| 3266 return true; | |
| 3267 } | |
| 3268 } | |
| 3269 p++; | |
| 3270 break; | |
| 3271 } | |
| 3272 default : | |
| 3273 *b++ = '%'; | |
| 3274 } | |
| 3275 } else { | |
| 3276 *b++ = *p++; | |
| 3277 } | |
| 3278 } | |
| 3279 *b = '\0'; | |
| 3280 return (p == src_end); // return false if not all of the source was copied | |
| 3281 } |