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