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