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