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