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