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