Mercurial > hg > truffle
annotate src/share/vm/runtime/java.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 | 9a86ddfc6c8f |
| children | a1b8cf9cf970 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
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:
1547
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1547
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:
1547
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/classLoader.hpp" | |
| 27 #include "classfile/symbolTable.hpp" | |
| 28 #include "classfile/systemDictionary.hpp" | |
| 29 #include "code/codeCache.hpp" | |
| 30 #include "compiler/compileBroker.hpp" | |
| 31 #include "compiler/compilerOracle.hpp" | |
| 32 #include "interpreter/bytecodeHistogram.hpp" | |
| 33 #include "memory/genCollectedHeap.hpp" | |
| 34 #include "memory/oopFactory.hpp" | |
| 35 #include "memory/universe.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
36 #include "oops/constantPool.hpp" |
| 1972 | 37 #include "oops/generateOopMap.hpp" |
| 38 #include "oops/instanceKlass.hpp" | |
| 39 #include "oops/instanceOop.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
40 #include "oops/method.hpp" |
| 1972 | 41 #include "oops/objArrayOop.hpp" |
| 42 #include "oops/oop.inline.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
43 #include "oops/symbol.hpp" |
| 1972 | 44 #include "prims/jvmtiExport.hpp" |
| 45 #include "runtime/aprofiler.hpp" | |
| 46 #include "runtime/arguments.hpp" | |
| 47 #include "runtime/biasedLocking.hpp" | |
| 48 #include "runtime/compilationPolicy.hpp" | |
| 49 #include "runtime/fprofiler.hpp" | |
| 50 #include "runtime/init.hpp" | |
| 51 #include "runtime/interfaceSupport.hpp" | |
| 52 #include "runtime/java.hpp" | |
| 53 #include "runtime/memprofiler.hpp" | |
| 54 #include "runtime/sharedRuntime.hpp" | |
| 55 #include "runtime/statSampler.hpp" | |
| 56 #include "runtime/task.hpp" | |
| 57 #include "runtime/timer.hpp" | |
| 58 #include "runtime/vm_operations.hpp" | |
|
6770
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
59 #include "services/memReporter.hpp" |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
60 #include "services/memTracker.hpp" |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
61 #include "trace/tracing.hpp" |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
62 #include "trace/traceEventTypes.hpp" |
| 1972 | 63 #include "utilities/dtrace.hpp" |
| 64 #include "utilities/globalDefinitions.hpp" | |
| 65 #include "utilities/histogram.hpp" | |
| 66 #include "utilities/vmError.hpp" | |
| 67 #ifdef TARGET_ARCH_x86 | |
| 68 # include "vm_version_x86.hpp" | |
| 69 #endif | |
| 70 #ifdef TARGET_ARCH_sparc | |
| 71 # include "vm_version_sparc.hpp" | |
| 72 #endif | |
| 73 #ifdef TARGET_ARCH_zero | |
| 74 # include "vm_version_zero.hpp" | |
| 75 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
76 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
77 # include "vm_version_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
78 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
79 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
80 # include "vm_version_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
81 #endif |
| 1972 | 82 #ifdef TARGET_OS_FAMILY_linux |
| 83 # include "thread_linux.inline.hpp" | |
| 84 #endif | |
| 85 #ifdef TARGET_OS_FAMILY_solaris | |
| 86 # include "thread_solaris.inline.hpp" | |
| 87 #endif | |
| 88 #ifdef TARGET_OS_FAMILY_windows | |
| 89 # include "thread_windows.inline.hpp" | |
| 90 #endif | |
| 3960 | 91 #ifdef TARGET_OS_FAMILY_bsd |
| 92 # include "thread_bsd.inline.hpp" | |
| 93 #endif | |
| 1972 | 94 #ifndef SERIALGC |
| 95 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" | |
| 96 #include "gc_implementation/parallelScavenge/psScavenge.hpp" | |
| 97 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" | |
| 98 #endif | |
| 99 #ifdef COMPILER1 | |
| 100 #include "c1/c1_Compiler.hpp" | |
| 101 #include "c1/c1_Runtime1.hpp" | |
| 102 #endif | |
| 103 #ifdef COMPILER2 | |
| 104 #include "code/compiledIC.hpp" | |
| 105 #include "compiler/methodLiveness.hpp" | |
| 106 #include "opto/compile.hpp" | |
| 107 #include "opto/indexSet.hpp" | |
| 108 #include "opto/runtime.hpp" | |
| 109 #endif | |
| 0 | 110 |
| 4006 | 111 #ifndef USDT2 |
| 0 | 112 HS_DTRACE_PROBE_DECL(hotspot, vm__shutdown); |
| 4006 | 113 #endif /* !USDT2 */ |
| 0 | 114 |
| 115 #ifndef PRODUCT | |
| 116 | |
| 117 // Statistics printing (method invocation histogram) | |
| 118 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
119 GrowableArray<Method*>* collected_invoked_methods; |
| 0 | 120 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
121 void collect_invoked_methods(Method* m) { |
| 0 | 122 if (m->invocation_count() + m->compiled_invocation_count() >= 1 ) { |
| 123 collected_invoked_methods->push(m); | |
| 124 } | |
| 125 } | |
| 126 | |
| 127 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
128 GrowableArray<Method*>* collected_profiled_methods; |
| 0 | 129 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
130 void collect_profiled_methods(Method* m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
131 Thread* thread = Thread::current(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
132 // This HandleMark prevents a huge amount of handles from being added |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
133 // to the metadata_handles() array on the thread. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
134 HandleMark hm(thread); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
135 methodHandle mh(thread, m); |
| 0 | 136 if ((m->method_data() != NULL) && |
| 137 (PrintMethodData || CompilerOracle::should_print(mh))) { | |
| 138 collected_profiled_methods->push(m); | |
| 139 } | |
| 140 } | |
| 141 | |
| 142 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
143 int compare_methods(Method** a, Method** b) { |
| 0 | 144 // %%% there can be 32-bit overflow here |
| 145 return ((*b)->invocation_count() + (*b)->compiled_invocation_count()) | |
| 146 - ((*a)->invocation_count() + (*a)->compiled_invocation_count()); | |
| 147 } | |
| 148 | |
| 149 | |
| 150 void print_method_invocation_histogram() { | |
| 151 ResourceMark rm; | |
| 152 HandleMark hm; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
153 collected_invoked_methods = new GrowableArray<Method*>(1024); |
| 0 | 154 SystemDictionary::methods_do(collect_invoked_methods); |
| 155 collected_invoked_methods->sort(&compare_methods); | |
| 156 // | |
| 157 tty->cr(); | |
| 158 tty->print_cr("Histogram Over MethodOop Invocation Counters (cutoff = %d):", MethodHistogramCutoff); | |
| 159 tty->cr(); | |
| 160 tty->print_cr("____Count_(I+C)____Method________________________Module_________________"); | |
| 161 unsigned total = 0, int_total = 0, comp_total = 0, static_total = 0, final_total = 0, | |
| 162 synch_total = 0, nativ_total = 0, acces_total = 0; | |
| 163 for (int index = 0; index < collected_invoked_methods->length(); index++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
164 Method* m = collected_invoked_methods->at(index); |
| 0 | 165 int c = m->invocation_count() + m->compiled_invocation_count(); |
| 166 if (c >= MethodHistogramCutoff) m->print_invocation_count(); | |
| 167 int_total += m->invocation_count(); | |
| 168 comp_total += m->compiled_invocation_count(); | |
| 169 if (m->is_final()) final_total += c; | |
| 170 if (m->is_static()) static_total += c; | |
| 171 if (m->is_synchronized()) synch_total += c; | |
| 172 if (m->is_native()) nativ_total += c; | |
| 173 if (m->is_accessor()) acces_total += c; | |
| 174 } | |
| 175 tty->cr(); | |
| 176 total = int_total + comp_total; | |
| 177 tty->print_cr("Invocations summary:"); | |
| 178 tty->print_cr("\t%9d (%4.1f%%) interpreted", int_total, 100.0 * int_total / total); | |
| 179 tty->print_cr("\t%9d (%4.1f%%) compiled", comp_total, 100.0 * comp_total / total); | |
| 180 tty->print_cr("\t%9d (100%%) total", total); | |
| 181 tty->print_cr("\t%9d (%4.1f%%) synchronized", synch_total, 100.0 * synch_total / total); | |
| 182 tty->print_cr("\t%9d (%4.1f%%) final", final_total, 100.0 * final_total / total); | |
| 183 tty->print_cr("\t%9d (%4.1f%%) static", static_total, 100.0 * static_total / total); | |
| 184 tty->print_cr("\t%9d (%4.1f%%) native", nativ_total, 100.0 * nativ_total / total); | |
| 185 tty->print_cr("\t%9d (%4.1f%%) accessor", acces_total, 100.0 * acces_total / total); | |
| 186 tty->cr(); | |
| 187 SharedRuntime::print_call_statistics(comp_total); | |
| 188 } | |
| 189 | |
| 190 void print_method_profiling_data() { | |
| 191 ResourceMark rm; | |
| 192 HandleMark hm; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
193 collected_profiled_methods = new GrowableArray<Method*>(1024); |
| 0 | 194 SystemDictionary::methods_do(collect_profiled_methods); |
| 195 collected_profiled_methods->sort(&compare_methods); | |
| 196 | |
| 197 int count = collected_profiled_methods->length(); | |
| 198 if (count > 0) { | |
| 199 for (int index = 0; index < count; index++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
200 Method* m = collected_profiled_methods->at(index); |
| 0 | 201 ttyLocker ttyl; |
| 202 tty->print_cr("------------------------------------------------------------------------"); | |
| 203 //m->print_name(tty); | |
| 204 m->print_invocation_count(); | |
| 205 tty->cr(); | |
| 206 m->print_codes(); | |
| 207 } | |
| 208 tty->print_cr("------------------------------------------------------------------------"); | |
| 209 } | |
| 210 } | |
| 211 | |
| 212 void print_bytecode_count() { | |
| 213 if (CountBytecodes || TraceBytecodes || StopInterpreterAt) { | |
| 214 tty->print_cr("[BytecodeCounter::counter_value = %d]", BytecodeCounter::counter_value()); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 AllocStats alloc_stats; | |
| 219 | |
| 220 | |
| 221 | |
| 222 // General statistics printing (profiling ...) | |
| 223 | |
| 224 void print_statistics() { | |
| 225 | |
| 226 #ifdef ASSERT | |
| 227 | |
| 228 if (CountRuntimeCalls) { | |
| 229 extern Histogram *RuntimeHistogram; | |
| 230 RuntimeHistogram->print(); | |
| 231 } | |
| 232 | |
| 233 if (CountJNICalls) { | |
| 234 extern Histogram *JNIHistogram; | |
| 235 JNIHistogram->print(); | |
| 236 } | |
| 237 | |
| 238 if (CountJVMCalls) { | |
| 239 extern Histogram *JVMHistogram; | |
| 240 JVMHistogram->print(); | |
| 241 } | |
| 242 | |
| 243 #endif | |
| 244 | |
| 245 if (MemProfiling) { | |
| 246 MemProfiler::disengage(); | |
| 247 } | |
| 248 | |
| 249 if (CITime) { | |
| 250 CompileBroker::print_times(); | |
| 251 } | |
| 252 | |
| 253 #ifdef COMPILER1 | |
| 254 if ((PrintC1Statistics || LogVMOutput || LogCompilation) && UseCompiler) { | |
| 255 FlagSetting fs(DisplayVMOutput, DisplayVMOutput && PrintC1Statistics); | |
| 256 Runtime1::print_statistics(); | |
| 257 Deoptimization::print_statistics(); | |
|
3841
0f34fdee809e
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
3769
diff
changeset
|
258 SharedRuntime::print_statistics(); |
| 0 | 259 nmethod::print_statistics(); |
| 260 } | |
| 261 #endif /* COMPILER1 */ | |
| 262 | |
| 263 #ifdef COMPILER2 | |
| 264 if ((PrintOptoStatistics || LogVMOutput || LogCompilation) && UseCompiler) { | |
| 265 FlagSetting fs(DisplayVMOutput, DisplayVMOutput && PrintOptoStatistics); | |
| 266 Compile::print_statistics(); | |
| 267 #ifndef COMPILER1 | |
| 268 Deoptimization::print_statistics(); | |
| 269 nmethod::print_statistics(); | |
|
3841
0f34fdee809e
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
3769
diff
changeset
|
270 SharedRuntime::print_statistics(); |
| 0 | 271 #endif //COMPILER1 |
| 272 os::print_statistics(); | |
| 273 } | |
| 274 | |
| 275 if (PrintLockStatistics || PrintPreciseBiasedLockingStatistics) { | |
| 276 OptoRuntime::print_named_counters(); | |
| 277 } | |
| 278 | |
| 279 if (TimeLivenessAnalysis) { | |
| 280 MethodLiveness::print_times(); | |
| 281 } | |
| 282 #ifdef ASSERT | |
| 283 if (CollectIndexSetStatistics) { | |
| 284 IndexSet::print_statistics(); | |
| 285 } | |
| 286 #endif // ASSERT | |
| 287 #endif // COMPILER2 | |
| 288 if (CountCompiledCalls) { | |
| 289 print_method_invocation_histogram(); | |
| 290 } | |
| 1918 | 291 if (ProfileInterpreter COMPILER1_PRESENT(|| C1UpdateMethodData)) { |
| 0 | 292 print_method_profiling_data(); |
| 293 } | |
| 294 if (TimeCompiler) { | |
| 295 COMPILER2_PRESENT(Compile::print_timers();) | |
| 296 } | |
| 297 if (TimeCompilationPolicy) { | |
| 298 CompilationPolicy::policy()->print_time(); | |
| 299 } | |
| 300 if (TimeOopMap) { | |
| 301 GenerateOopMap::print_time(); | |
| 302 } | |
| 303 if (ProfilerCheckIntervals) { | |
| 304 PeriodicTask::print_intervals(); | |
| 305 } | |
| 306 if (PrintSymbolTableSizeHistogram) { | |
| 307 SymbolTable::print_histogram(); | |
| 308 } | |
| 309 if (CountBytecodes || TraceBytecodes || StopInterpreterAt) { | |
| 310 BytecodeCounter::print(); | |
| 311 } | |
| 312 if (PrintBytecodePairHistogram) { | |
| 313 BytecodePairHistogram::print(); | |
| 314 } | |
| 315 | |
| 316 if (PrintCodeCache) { | |
| 317 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
| 318 CodeCache::print(); | |
| 319 } | |
| 320 | |
| 321 if (PrintCodeCache2) { | |
| 322 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
| 323 CodeCache::print_internals(); | |
| 324 } | |
| 325 | |
| 326 if (PrintClassStatistics) { | |
| 327 SystemDictionary::print_class_statistics(); | |
| 328 } | |
| 329 if (PrintMethodStatistics) { | |
| 330 SystemDictionary::print_method_statistics(); | |
| 331 } | |
| 332 | |
| 333 if (PrintVtableStats) { | |
| 334 klassVtable::print_statistics(); | |
| 335 klassItable::print_statistics(); | |
| 336 } | |
| 337 if (VerifyOops) { | |
| 338 tty->print_cr("+VerifyOops count: %d", StubRoutines::verify_oop_count()); | |
| 339 } | |
| 340 | |
| 341 print_bytecode_count(); | |
| 2250 | 342 if (PrintMallocStatistics) { |
| 0 | 343 tty->print("allocation stats: "); |
| 344 alloc_stats.print(); | |
| 345 tty->cr(); | |
| 346 } | |
| 347 | |
| 348 if (PrintSystemDictionaryAtExit) { | |
| 349 SystemDictionary::print(); | |
| 350 } | |
| 351 | |
| 352 if (PrintBiasedLockingStatistics) { | |
| 353 BiasedLocking::print_counters(); | |
| 354 } | |
| 355 | |
| 356 #ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 357 #ifdef COMPILER2 | |
| 358 if (ZapDeadCompiledLocals) { | |
| 359 tty->print_cr("Compile::CompiledZap_count = %d", Compile::CompiledZap_count); | |
| 360 tty->print_cr("OptoRuntime::ZapDeadCompiledLocals_count = %d", OptoRuntime::ZapDeadCompiledLocals_count); | |
| 361 } | |
| 362 #endif // COMPILER2 | |
| 363 #endif // ENABLE_ZAP_DEAD_LOCALS | |
|
6770
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
364 // Native memory tracking data |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
365 if (PrintNMTStatistics) { |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
366 if (MemTracker::is_on()) { |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
367 BaselineTTYOutputer outputer(tty); |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
368 MemTracker::print_memory_usage(outputer, K, false); |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
369 } else { |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
370 tty->print_cr(MemTracker::reason()); |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
371 } |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
372 } |
| 0 | 373 } |
| 374 | |
| 375 #else // PRODUCT MODE STATISTICS | |
| 376 | |
| 377 void print_statistics() { | |
| 378 | |
| 379 if (CITime) { | |
| 380 CompileBroker::print_times(); | |
| 381 } | |
| 382 #ifdef COMPILER2 | |
| 383 if (PrintPreciseBiasedLockingStatistics) { | |
| 384 OptoRuntime::print_named_counters(); | |
| 385 } | |
| 386 #endif | |
| 387 if (PrintBiasedLockingStatistics) { | |
| 388 BiasedLocking::print_counters(); | |
| 389 } | |
|
6770
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
390 |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
391 // Native memory tracking data |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
392 if (PrintNMTStatistics) { |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
393 if (MemTracker::is_on()) { |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
394 BaselineTTYOutputer outputer(tty); |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
395 MemTracker::print_memory_usage(outputer, K, false); |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
396 } else { |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
397 tty->print_cr(MemTracker::reason()); |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
398 } |
|
9a86ddfc6c8f
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
6725
diff
changeset
|
399 } |
| 0 | 400 } |
| 401 | |
| 402 #endif | |
| 403 | |
| 404 | |
| 405 // Helper class for registering on_exit calls through JVM_OnExit | |
| 406 | |
| 407 extern "C" { | |
| 408 typedef void (*__exit_proc)(void); | |
| 409 } | |
| 410 | |
| 6197 | 411 class ExitProc : public CHeapObj<mtInternal> { |
| 0 | 412 private: |
| 413 __exit_proc _proc; | |
| 414 // void (*_proc)(void); | |
| 415 ExitProc* _next; | |
| 416 public: | |
| 417 // ExitProc(void (*proc)(void)) { | |
| 418 ExitProc(__exit_proc proc) { | |
| 419 _proc = proc; | |
| 420 _next = NULL; | |
| 421 } | |
| 422 void evaluate() { _proc(); } | |
| 423 ExitProc* next() const { return _next; } | |
| 424 void set_next(ExitProc* next) { _next = next; } | |
| 425 }; | |
| 426 | |
| 427 | |
| 428 // Linked list of registered on_exit procedures | |
| 429 | |
| 430 static ExitProc* exit_procs = NULL; | |
| 431 | |
| 432 | |
| 433 extern "C" { | |
| 434 void register_on_exit_function(void (*func)(void)) { | |
| 435 ExitProc *entry = new ExitProc(func); | |
| 436 // Classic vm does not throw an exception in case the allocation failed, | |
| 437 if (entry != NULL) { | |
| 438 entry->set_next(exit_procs); | |
| 439 exit_procs = entry; | |
| 440 } | |
| 441 } | |
| 442 } | |
| 443 | |
| 444 // Note: before_exit() can be executed only once, if more than one threads | |
| 445 // are trying to shutdown the VM at the same time, only one thread | |
| 446 // can run before_exit() and all other threads must wait. | |
| 447 void before_exit(JavaThread * thread) { | |
| 448 #define BEFORE_EXIT_NOT_RUN 0 | |
| 449 #define BEFORE_EXIT_RUNNING 1 | |
| 450 #define BEFORE_EXIT_DONE 2 | |
| 451 static jint volatile _before_exit_status = BEFORE_EXIT_NOT_RUN; | |
| 452 | |
| 453 // Note: don't use a Mutex to guard the entire before_exit(), as | |
| 454 // JVMTI post_thread_end_event and post_vm_death_event will run native code. | |
| 455 // A CAS or OSMutex would work just fine but then we need to manipulate | |
| 456 // thread state for Safepoint. Here we use Monitor wait() and notify_all() | |
| 457 // for synchronization. | |
| 458 { MutexLocker ml(BeforeExit_lock); | |
| 459 switch (_before_exit_status) { | |
| 460 case BEFORE_EXIT_NOT_RUN: | |
| 461 _before_exit_status = BEFORE_EXIT_RUNNING; | |
| 462 break; | |
| 463 case BEFORE_EXIT_RUNNING: | |
| 464 while (_before_exit_status == BEFORE_EXIT_RUNNING) { | |
| 465 BeforeExit_lock->wait(); | |
| 466 } | |
| 467 assert(_before_exit_status == BEFORE_EXIT_DONE, "invalid state"); | |
| 468 return; | |
| 469 case BEFORE_EXIT_DONE: | |
| 470 return; | |
| 471 } | |
| 472 } | |
| 473 | |
| 474 // The only difference between this and Win32's _onexit procs is that | |
| 475 // this version is invoked before any threads get killed. | |
| 476 ExitProc* current = exit_procs; | |
| 477 while (current != NULL) { | |
| 478 ExitProc* next = current->next(); | |
| 479 current->evaluate(); | |
| 480 delete current; | |
| 481 current = next; | |
| 482 } | |
| 483 | |
| 484 // Hang forever on exit if we're reporting an error. | |
| 485 if (ShowMessageBoxOnError && is_error_reported()) { | |
| 486 os::infinite_sleep(); | |
| 487 } | |
| 488 | |
| 489 // Terminate watcher thread - must before disenrolling any periodic task | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
490 if (PeriodicTask::num_tasks() > 0) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
491 WatcherThread::stop(); |
| 0 | 492 |
| 493 // Print statistics gathered (profiling ...) | |
| 494 if (Arguments::has_profile()) { | |
| 495 FlatProfiler::disengage(); | |
| 496 FlatProfiler::print(10); | |
| 497 } | |
| 498 | |
| 499 // shut down the StatSampler task | |
| 500 StatSampler::disengage(); | |
| 501 StatSampler::destroy(); | |
| 502 | |
|
3769
ef2d1b8f2dd4
7051430: CMS: ongoing CMS cycle should terminate abruptly to allow prompt JVM termination at exit
ysr
parents:
2304
diff
changeset
|
503 // We do not need to explicitly stop concurrent GC threads because the |
|
ef2d1b8f2dd4
7051430: CMS: ongoing CMS cycle should terminate abruptly to allow prompt JVM termination at exit
ysr
parents:
2304
diff
changeset
|
504 // JVM will be taken down at a safepoint when such threads are inactive -- |
|
ef2d1b8f2dd4
7051430: CMS: ongoing CMS cycle should terminate abruptly to allow prompt JVM termination at exit
ysr
parents:
2304
diff
changeset
|
505 // except for some concurrent G1 threads, see (comment in) |
|
ef2d1b8f2dd4
7051430: CMS: ongoing CMS cycle should terminate abruptly to allow prompt JVM termination at exit
ysr
parents:
2304
diff
changeset
|
506 // Threads::destroy_vm(). |
| 0 | 507 |
| 508 // Print GC/heap related information. | |
| 509 if (PrintGCDetails) { | |
| 510 Universe::print(); | |
| 511 AdaptiveSizePolicyOutput(0); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
512 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
513 ClassLoaderDataGraph::dump_on(gclog_or_tty); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6198
diff
changeset
|
514 } |
| 0 | 515 } |
| 516 | |
| 517 | |
| 518 if (Arguments::has_alloc_profile()) { | |
| 519 HandleMark hm; | |
| 520 // Do one last collection to enumerate all the objects | |
| 521 // allocated since the last one. | |
| 522 Universe::heap()->collect(GCCause::_allocation_profiler); | |
| 523 AllocationProfiler::disengage(); | |
| 524 AllocationProfiler::print(0); | |
| 525 } | |
| 526 | |
| 527 if (PrintBytecodeHistogram) { | |
| 528 BytecodeHistogram::print(); | |
| 529 } | |
| 530 | |
| 531 if (JvmtiExport::should_post_thread_life()) { | |
| 532 JvmtiExport::post_thread_end(thread); | |
| 533 } | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
534 |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
535 EVENT_BEGIN(TraceEventThreadEnd, event); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
536 EVENT_COMMIT(event, |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
537 EVENT_SET(event, javalangthread, java_lang_Thread::thread_id(thread->threadObj()))); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4006
diff
changeset
|
538 |
| 0 | 539 // Always call even when there are not JVMTI environments yet, since environments |
| 540 // may be attached late and JVMTI must track phases of VM execution | |
| 541 JvmtiExport::post_vm_death(); | |
| 542 Threads::shutdown_vm_agents(); | |
| 543 | |
| 544 // Terminate the signal thread | |
| 545 // Note: we don't wait until it actually dies. | |
| 546 os::terminate_signal_thread(); | |
| 547 | |
| 548 print_statistics(); | |
| 549 Universe::heap()->print_tracing_info(); | |
| 550 | |
| 551 { MutexLocker ml(BeforeExit_lock); | |
| 552 _before_exit_status = BEFORE_EXIT_DONE; | |
| 553 BeforeExit_lock->notify_all(); | |
| 554 } | |
| 555 | |
| 556 #undef BEFORE_EXIT_NOT_RUN | |
| 557 #undef BEFORE_EXIT_RUNNING | |
| 558 #undef BEFORE_EXIT_DONE | |
| 559 } | |
| 560 | |
| 561 void vm_exit(int code) { | |
|
2096
0eb90baf1b69
6583275: Hotspot crash in vm_perform_shutdown_actions due to uninitialized TLS during out of memory handling
coleenp
parents:
1972
diff
changeset
|
562 Thread* thread = ThreadLocalStorage::is_initialized() ? |
|
0eb90baf1b69
6583275: Hotspot crash in vm_perform_shutdown_actions due to uninitialized TLS during out of memory handling
coleenp
parents:
1972
diff
changeset
|
563 ThreadLocalStorage::get_thread_slow() : NULL; |
| 0 | 564 if (thread == NULL) { |
| 565 // we have serious problems -- just exit | |
| 566 vm_direct_exit(code); | |
| 567 } | |
| 568 | |
| 569 if (VMThread::vm_thread() != NULL) { | |
| 570 // Fire off a VM_Exit operation to bring VM to a safepoint and exit | |
| 571 VM_Exit op(code); | |
| 572 if (thread->is_Java_thread()) | |
| 573 ((JavaThread*)thread)->set_thread_state(_thread_in_vm); | |
| 574 VMThread::execute(&op); | |
| 575 // should never reach here; but in case something wrong with VM Thread. | |
| 576 vm_direct_exit(code); | |
| 577 } else { | |
| 578 // VM thread is gone, just exit | |
| 579 vm_direct_exit(code); | |
| 580 } | |
| 581 ShouldNotReachHere(); | |
| 582 } | |
| 583 | |
| 584 void notify_vm_shutdown() { | |
| 585 // For now, just a dtrace probe. | |
| 4006 | 586 #ifndef USDT2 |
| 0 | 587 HS_DTRACE_PROBE(hotspot, vm__shutdown); |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
242
diff
changeset
|
588 HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); |
| 4006 | 589 #else /* USDT2 */ |
| 590 HOTSPOT_VM_SHUTDOWN(); | |
| 591 #endif /* USDT2 */ | |
| 0 | 592 } |
| 593 | |
| 594 void vm_direct_exit(int code) { | |
| 595 notify_vm_shutdown(); | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2192
diff
changeset
|
596 os::wait_for_keypress_at_exit(); |
| 0 | 597 ::exit(code); |
| 598 } | |
| 599 | |
| 600 void vm_perform_shutdown_actions() { | |
| 601 // Warning: do not call 'exit_globals()' here. All threads are still running. | |
| 602 // Calling 'exit_globals()' will disable thread-local-storage and cause all | |
| 603 // kinds of assertions to trigger in debug mode. | |
| 604 if (is_init_completed()) { | |
|
2096
0eb90baf1b69
6583275: Hotspot crash in vm_perform_shutdown_actions due to uninitialized TLS during out of memory handling
coleenp
parents:
1972
diff
changeset
|
605 Thread* thread = ThreadLocalStorage::is_initialized() ? |
|
0eb90baf1b69
6583275: Hotspot crash in vm_perform_shutdown_actions due to uninitialized TLS during out of memory handling
coleenp
parents:
1972
diff
changeset
|
606 ThreadLocalStorage::get_thread_slow() : NULL; |
|
0eb90baf1b69
6583275: Hotspot crash in vm_perform_shutdown_actions due to uninitialized TLS during out of memory handling
coleenp
parents:
1972
diff
changeset
|
607 if (thread != NULL && thread->is_Java_thread()) { |
| 0 | 608 // We are leaving the VM, set state to native (in case any OS exit |
| 609 // handlers call back to the VM) | |
| 610 JavaThread* jt = (JavaThread*)thread; | |
| 611 // Must always be walkable or have no last_Java_frame when in | |
| 612 // thread_in_native | |
| 613 jt->frame_anchor()->make_walkable(jt); | |
| 614 jt->set_thread_state(_thread_in_native); | |
| 615 } | |
| 616 } | |
| 617 notify_vm_shutdown(); | |
| 618 } | |
| 619 | |
| 620 void vm_shutdown() | |
| 621 { | |
| 622 vm_perform_shutdown_actions(); | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2192
diff
changeset
|
623 os::wait_for_keypress_at_exit(); |
| 0 | 624 os::shutdown(); |
| 625 } | |
| 626 | |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
627 void vm_abort(bool dump_core) { |
| 0 | 628 vm_perform_shutdown_actions(); |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2192
diff
changeset
|
629 os::wait_for_keypress_at_exit(); |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
630 os::abort(dump_core); |
| 0 | 631 ShouldNotReachHere(); |
| 632 } | |
| 633 | |
| 634 void vm_notify_during_shutdown(const char* error, const char* message) { | |
| 635 if (error != NULL) { | |
| 636 tty->print_cr("Error occurred during initialization of VM"); | |
| 637 tty->print("%s", error); | |
| 638 if (message != NULL) { | |
| 639 tty->print_cr(": %s", message); | |
| 640 } | |
| 641 else { | |
| 642 tty->cr(); | |
| 643 } | |
| 644 } | |
| 645 if (ShowMessageBoxOnError && WizardMode) { | |
| 646 fatal("Error occurred during initialization of VM"); | |
| 647 } | |
| 648 } | |
| 649 | |
| 650 void vm_exit_during_initialization(Handle exception) { | |
| 651 tty->print_cr("Error occurred during initialization of VM"); | |
| 652 // If there are exceptions on this thread it must be cleared | |
| 653 // first and here. Any future calls to EXCEPTION_MARK requires | |
| 654 // that no pending exceptions exist. | |
| 655 Thread *THREAD = Thread::current(); | |
| 656 if (HAS_PENDING_EXCEPTION) { | |
| 657 CLEAR_PENDING_EXCEPTION; | |
| 658 } | |
| 659 java_lang_Throwable::print(exception, tty); | |
| 660 tty->cr(); | |
| 661 java_lang_Throwable::print_stack_trace(exception(), tty); | |
| 662 tty->cr(); | |
| 663 vm_notify_during_shutdown(NULL, NULL); | |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
664 |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
665 // Failure during initialization, we don't want to dump core |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
666 vm_abort(false); |
| 0 | 667 } |
| 668 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
669 void vm_exit_during_initialization(Symbol* ex, const char* message) { |
| 0 | 670 ResourceMark rm; |
| 671 vm_notify_during_shutdown(ex->as_C_string(), message); | |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
672 |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
673 // Failure during initialization, we don't want to dump core |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
674 vm_abort(false); |
| 0 | 675 } |
| 676 | |
| 677 void vm_exit_during_initialization(const char* error, const char* message) { | |
| 678 vm_notify_during_shutdown(error, message); | |
|
227
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
679 |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
680 // Failure during initialization, we don't want to dump core |
|
8d852b81e775
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
61
diff
changeset
|
681 vm_abort(false); |
| 0 | 682 } |
| 683 | |
| 684 void vm_shutdown_during_initialization(const char* error, const char* message) { | |
| 685 vm_notify_during_shutdown(error, message); | |
| 686 vm_shutdown(); | |
| 687 } | |
| 688 | |
| 242 | 689 JDK_Version JDK_Version::_current; |
| 6181 | 690 const char* JDK_Version::_runtime_name; |
| 0 | 691 |
| 692 void JDK_Version::initialize() { | |
| 242 | 693 jdk_version_info info; |
| 694 assert(!_current.is_valid(), "Don't initialize twice"); | |
| 695 | |
| 0 | 696 void *lib_handle = os::native_java_library(); |
| 242 | 697 jdk_version_info_fn_t func = CAST_TO_FN_PTR(jdk_version_info_fn_t, |
| 698 os::dll_lookup(lib_handle, "JDK_GetVersionInfo0")); | |
| 0 | 699 |
| 700 if (func == NULL) { | |
| 701 // JDK older than 1.6 | |
| 242 | 702 _current._partially_initialized = true; |
| 703 } else { | |
| 704 (*func)(&info, sizeof(info)); | |
| 0 | 705 |
| 242 | 706 int major = JDK_VERSION_MAJOR(info.jdk_version); |
| 707 int minor = JDK_VERSION_MINOR(info.jdk_version); | |
| 708 int micro = JDK_VERSION_MICRO(info.jdk_version); | |
| 709 int build = JDK_VERSION_BUILD(info.jdk_version); | |
| 710 if (major == 1 && minor > 4) { | |
| 711 // We represent "1.5.0" as "5.0", but 1.4.2 as itself. | |
| 712 major = minor; | |
| 713 minor = micro; | |
| 714 micro = 0; | |
| 715 } | |
| 716 _current = JDK_Version(major, minor, micro, info.update_version, | |
| 717 info.special_update_version, build, | |
|
2129
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2096
diff
changeset
|
718 info.thread_park_blocker == 1, |
|
3917
eca1193ca245
4965777: GC changes to support use of discovered field for pending references
ysr
parents:
3841
diff
changeset
|
719 info.post_vm_init_hook_enabled == 1, |
|
eca1193ca245
4965777: GC changes to support use of discovered field for pending references
ysr
parents:
3841
diff
changeset
|
720 info.pending_list_uses_discovered_field == 1); |
| 0 | 721 } |
| 242 | 722 } |
| 723 | |
| 724 void JDK_Version::fully_initialize( | |
| 725 uint8_t major, uint8_t minor, uint8_t micro, uint8_t update) { | |
| 726 // This is only called when current is less than 1.6 and we've gotten | |
| 727 // far enough in the initialization to determine the exact version. | |
| 728 assert(major < 6, "not needed for JDK version >= 6"); | |
| 729 assert(is_partially_initialized(), "must not initialize"); | |
| 730 if (major < 5) { | |
| 731 // JDK verison sequence: 1.2.x, 1.3.x, 1.4.x, 5.0.x, 6.0.x, etc. | |
| 732 micro = minor; | |
| 733 minor = major; | |
| 734 major = 1; | |
| 0 | 735 } |
| 242 | 736 _current = JDK_Version(major, minor, micro, update); |
| 0 | 737 } |
| 738 | |
| 739 void JDK_Version_init() { | |
| 740 JDK_Version::initialize(); | |
| 741 } | |
| 242 | 742 |
| 743 static int64_t encode_jdk_version(const JDK_Version& v) { | |
| 744 return | |
| 745 ((int64_t)v.major_version() << (BitsPerByte * 5)) | | |
| 746 ((int64_t)v.minor_version() << (BitsPerByte * 4)) | | |
| 747 ((int64_t)v.micro_version() << (BitsPerByte * 3)) | | |
| 748 ((int64_t)v.update_version() << (BitsPerByte * 2)) | | |
| 749 ((int64_t)v.special_update_version() << (BitsPerByte * 1)) | | |
| 750 ((int64_t)v.build_number() << (BitsPerByte * 0)); | |
| 751 } | |
| 752 | |
| 753 int JDK_Version::compare(const JDK_Version& other) const { | |
| 754 assert(is_valid() && other.is_valid(), "Invalid version (uninitialized?)"); | |
| 755 if (!is_partially_initialized() && other.is_partially_initialized()) { | |
| 756 return -(other.compare(*this)); // flip the comparators | |
| 757 } | |
| 758 assert(!other.is_partially_initialized(), "Not initialized yet"); | |
| 759 if (is_partially_initialized()) { | |
| 760 assert(other.major_version() >= 6, | |
| 761 "Invalid JDK version comparison during initialization"); | |
| 762 return -1; | |
| 763 } else { | |
| 764 uint64_t e = encode_jdk_version(*this); | |
| 765 uint64_t o = encode_jdk_version(other); | |
| 766 return (e > o) ? 1 : ((e == o) ? 0 : -1); | |
| 767 } | |
| 768 } | |
| 769 | |
| 770 void JDK_Version::to_string(char* buffer, size_t buflen) const { | |
| 771 size_t index = 0; | |
| 772 if (!is_valid()) { | |
| 773 jio_snprintf(buffer, buflen, "%s", "(uninitialized)"); | |
| 774 } else if (is_partially_initialized()) { | |
| 775 jio_snprintf(buffer, buflen, "%s", "(uninitialized) pre-1.6.0"); | |
| 776 } else { | |
| 777 index += jio_snprintf( | |
| 778 &buffer[index], buflen - index, "%d.%d", _major, _minor); | |
| 779 if (_micro > 0) { | |
| 780 index += jio_snprintf(&buffer[index], buflen - index, ".%d", _micro); | |
| 781 } | |
| 782 if (_update > 0) { | |
| 783 index += jio_snprintf(&buffer[index], buflen - index, "_%02d", _update); | |
| 784 } | |
| 785 if (_special > 0) { | |
| 786 index += jio_snprintf(&buffer[index], buflen - index, "%c", _special); | |
| 787 } | |
| 788 if (_build > 0) { | |
| 789 index += jio_snprintf(&buffer[index], buflen - index, "-b%02d", _build); | |
| 790 } | |
| 791 } | |
| 792 } |