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