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