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