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