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