author | chegar |
Thu, 17 Oct 2019 20:54:25 +0100 | |
branch | datagramsocketimpl-branch |
changeset 58679 | 9c3209ff7550 |
parent 58678 | 9cf78a70fa4f |
parent 58545 | 725244418646 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53194
c4a64760b1b0
8216359: Remove develop flags TraceCompilationPolicy and TimeCompilationPolicy
redestad
parents:
52877
diff
changeset
|
2 |
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5542
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5542
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5542
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
26 |
#include "jvm.h" |
42650 | 27 |
#include "aot/aotLoader.hpp" |
7397 | 28 |
#include "classfile/classLoader.hpp" |
51959
db0c3952de52
8209645: Split ClassLoaderData and ClassLoaderDataGraph into separate files
coleenp
parents:
51649
diff
changeset
|
29 |
#include "classfile/classLoaderDataGraph.hpp" |
24426
0a69c8cdfca9
8038654: Separate SymbolTable and StringTable code
gziemski
parents:
24093
diff
changeset
|
30 |
#include "classfile/stringTable.hpp" |
54786 | 31 |
#include "classfile/symbolTable.hpp" |
7397 | 32 |
#include "classfile/systemDictionary.hpp" |
33 |
#include "code/codeCache.hpp" |
|
34 |
#include "compiler/compileBroker.hpp" |
|
35 |
#include "compiler/compilerOracle.hpp" |
|
36 |
#include "interpreter/bytecodeHistogram.hpp" |
|
50124
781f36c0831e
8203285: Minimal VM fails to build after JDK-8199712 (Flight Recorder)
shade
parents:
50113
diff
changeset
|
37 |
#include "jfr/jfrEvents.hpp" |
50113 | 38 |
#include "jfr/support/jfrThreadId.hpp" |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
39 |
#if INCLUDE_JVMCI |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
40 |
#include "jvmci/jvmci.hpp" |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
41 |
#endif |
35061 | 42 |
#include "logging/log.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46657
diff
changeset
|
43 |
#include "logging/logStream.hpp" |
7397 | 44 |
#include "memory/oopFactory.hpp" |
37248 | 45 |
#include "memory/resourceArea.hpp" |
54927 | 46 |
#include "memory/dynamicArchive.hpp" |
7397 | 47 |
#include "memory/universe.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
48 |
#include "oops/constantPool.hpp" |
7397 | 49 |
#include "oops/generateOopMap.hpp" |
50 |
#include "oops/instanceKlass.hpp" |
|
51 |
#include "oops/instanceOop.hpp" |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
52 |
#include "oops/method.hpp" |
7397 | 53 |
#include "oops/objArrayOop.hpp" |
54 |
#include "oops/oop.inline.hpp" |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7900
diff
changeset
|
55 |
#include "oops/symbol.hpp" |
7397 | 56 |
#include "prims/jvmtiExport.hpp" |
57 |
#include "runtime/arguments.hpp" |
|
58 |
#include "runtime/biasedLocking.hpp" |
|
34230
b9c64b7c06c9
8141570: Fix Zero interpreter build for --disable-precompiled-headers
coleenp
parents:
33600
diff
changeset
|
59 |
#include "runtime/deoptimization.hpp" |
49902
3661f31c6df4
8202150: [REDO] Split globals.hpp to factor out the Flag class
gziemski
parents:
49860
diff
changeset
|
60 |
#include "runtime/flags/flagSetting.hpp" |
53582 | 61 |
#include "runtime/handles.inline.hpp" |
7397 | 62 |
#include "runtime/init.hpp" |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49348
diff
changeset
|
63 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 64 |
#include "runtime/java.hpp" |
65 |
#include "runtime/memprofiler.hpp" |
|
66 |
#include "runtime/sharedRuntime.hpp" |
|
67 |
#include "runtime/statSampler.hpp" |
|
22210
b0408ba029f6
8025277: Add -XX: flag to print code cache sweeper statistics
anoll
parents:
21095
diff
changeset
|
68 |
#include "runtime/sweeper.hpp" |
7397 | 69 |
#include "runtime/task.hpp" |
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14289
diff
changeset
|
70 |
#include "runtime/thread.inline.hpp" |
7397 | 71 |
#include "runtime/timer.hpp" |
52877
9e041366c764
8214850: Rename vm_operations.?pp files to vmOperations.?pp files
tschatzl
parents:
52815
diff
changeset
|
72 |
#include "runtime/vmOperations.hpp" |
13861
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
73 |
#include "services/memTracker.hpp" |
7397 | 74 |
#include "utilities/dtrace.hpp" |
75 |
#include "utilities/globalDefinitions.hpp" |
|
76 |
#include "utilities/histogram.hpp" |
|
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
15202
diff
changeset
|
77 |
#include "utilities/macros.hpp" |
7397 | 78 |
#include "utilities/vmError.hpp" |
79 |
#ifdef COMPILER1 |
|
80 |
#include "c1/c1_Compiler.hpp" |
|
81 |
#include "c1/c1_Runtime1.hpp" |
|
82 |
#endif |
|
83 |
#ifdef COMPILER2 |
|
84 |
#include "code/compiledIC.hpp" |
|
85 |
#include "opto/compile.hpp" |
|
86 |
#include "opto/indexSet.hpp" |
|
87 |
#include "opto/runtime.hpp" |
|
88 |
#endif |
|
50113 | 89 |
#if INCLUDE_JFR |
90 |
#include "jfr/jfr.hpp" |
|
91 |
#endif |
|
1 | 92 |
|
23526
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
93 |
GrowableArray<Method*>* collected_profiled_methods; |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
94 |
|
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
95 |
int compare_methods(Method** a, Method** b) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
96 |
// %%% there can be 32-bit overflow here |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
97 |
return ((*b)->invocation_count() + (*b)->compiled_invocation_count()) |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
98 |
- ((*a)->invocation_count() + (*a)->compiled_invocation_count()); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
99 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
100 |
|
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
101 |
void collect_profiled_methods(Method* m) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
102 |
Thread* thread = Thread::current(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
103 |
methodHandle mh(thread, m); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
104 |
if ((m->method_data() != NULL) && |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
105 |
(PrintMethodData || CompilerOracle::should_print(mh))) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
106 |
collected_profiled_methods->push(m); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
107 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
108 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
109 |
|
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
110 |
void print_method_profiling_data() { |
24658
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24429
diff
changeset
|
111 |
if (ProfileInterpreter COMPILER1_PRESENT(|| C1UpdateMethodData) && |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24429
diff
changeset
|
112 |
(PrintMethodData || CompilerOracle::should_print_methods())) { |
23526
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
113 |
ResourceMark rm; |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
114 |
HandleMark hm; |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
115 |
collected_profiled_methods = new GrowableArray<Method*>(1024); |
46380
4a51438196cf
8026985: Rewrite SystemDictionary::classes_do and Dictionary::classes_do to use KlassClosure
coleenp
parents:
46369
diff
changeset
|
116 |
SystemDictionary::methods_do(collect_profiled_methods); |
23526
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
117 |
collected_profiled_methods->sort(&compare_methods); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
118 |
|
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
119 |
int count = collected_profiled_methods->length(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
120 |
int total_size = 0; |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
121 |
if (count > 0) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
122 |
for (int index = 0; index < count; index++) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
123 |
Method* m = collected_profiled_methods->at(index); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
124 |
ttyLocker ttyl; |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
125 |
tty->print_cr("------------------------------------------------------------------------"); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
126 |
m->print_invocation_count(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
127 |
tty->print_cr(" mdo size: %d bytes", m->method_data()->size_in_bytes()); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
128 |
tty->cr(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
129 |
// Dump data on parameters if any |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
130 |
if (m->method_data() != NULL && m->method_data()->parameters_type_data() != NULL) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
131 |
tty->fill_to(2); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
132 |
m->method_data()->parameters_type_data()->print_data_on(tty); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
133 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
134 |
m->print_codes(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
135 |
total_size += m->method_data()->size_in_bytes(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
136 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
137 |
tty->print_cr("------------------------------------------------------------------------"); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
138 |
tty->print_cr("Total MDO size: %d bytes", total_size); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
139 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
140 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
141 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
142 |
|
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
143 |
|
1 | 144 |
#ifndef PRODUCT |
145 |
||
146 |
// Statistics printing (method invocation histogram) |
|
147 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
148 |
GrowableArray<Method*>* collected_invoked_methods; |
1 | 149 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
150 |
void collect_invoked_methods(Method* m) { |
1 | 151 |
if (m->invocation_count() + m->compiled_invocation_count() >= 1 ) { |
152 |
collected_invoked_methods->push(m); |
|
153 |
} |
|
154 |
} |
|
155 |
||
156 |
||
157 |
||
158 |
||
159 |
void print_method_invocation_histogram() { |
|
160 |
ResourceMark rm; |
|
161 |
HandleMark hm; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
162 |
collected_invoked_methods = new GrowableArray<Method*>(1024); |
1 | 163 |
SystemDictionary::methods_do(collect_invoked_methods); |
164 |
collected_invoked_methods->sort(&compare_methods); |
|
165 |
// |
|
166 |
tty->cr(); |
|
46380
4a51438196cf
8026985: Rewrite SystemDictionary::classes_do and Dictionary::classes_do to use KlassClosure
coleenp
parents:
46369
diff
changeset
|
167 |
tty->print_cr("Histogram Over Method Invocation Counters (cutoff = " INTX_FORMAT "):", MethodHistogramCutoff); |
1 | 168 |
tty->cr(); |
169 |
tty->print_cr("____Count_(I+C)____Method________________________Module_________________"); |
|
170 |
unsigned total = 0, int_total = 0, comp_total = 0, static_total = 0, final_total = 0, |
|
171 |
synch_total = 0, nativ_total = 0, acces_total = 0; |
|
172 |
for (int index = 0; index < collected_invoked_methods->length(); index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
173 |
Method* m = collected_invoked_methods->at(index); |
1 | 174 |
int c = m->invocation_count() + m->compiled_invocation_count(); |
175 |
if (c >= MethodHistogramCutoff) m->print_invocation_count(); |
|
176 |
int_total += m->invocation_count(); |
|
177 |
comp_total += m->compiled_invocation_count(); |
|
178 |
if (m->is_final()) final_total += c; |
|
179 |
if (m->is_static()) static_total += c; |
|
180 |
if (m->is_synchronized()) synch_total += c; |
|
181 |
if (m->is_native()) nativ_total += c; |
|
182 |
if (m->is_accessor()) acces_total += c; |
|
183 |
} |
|
184 |
tty->cr(); |
|
185 |
total = int_total + comp_total; |
|
186 |
tty->print_cr("Invocations summary:"); |
|
187 |
tty->print_cr("\t%9d (%4.1f%%) interpreted", int_total, 100.0 * int_total / total); |
|
188 |
tty->print_cr("\t%9d (%4.1f%%) compiled", comp_total, 100.0 * comp_total / total); |
|
189 |
tty->print_cr("\t%9d (100%%) total", total); |
|
190 |
tty->print_cr("\t%9d (%4.1f%%) synchronized", synch_total, 100.0 * synch_total / total); |
|
191 |
tty->print_cr("\t%9d (%4.1f%%) final", final_total, 100.0 * final_total / total); |
|
192 |
tty->print_cr("\t%9d (%4.1f%%) static", static_total, 100.0 * static_total / total); |
|
193 |
tty->print_cr("\t%9d (%4.1f%%) native", nativ_total, 100.0 * nativ_total / total); |
|
194 |
tty->print_cr("\t%9d (%4.1f%%) accessor", acces_total, 100.0 * acces_total / total); |
|
195 |
tty->cr(); |
|
196 |
SharedRuntime::print_call_statistics(comp_total); |
|
197 |
} |
|
198 |
||
199 |
void print_bytecode_count() { |
|
200 |
if (CountBytecodes || TraceBytecodes || StopInterpreterAt) { |
|
201 |
tty->print_cr("[BytecodeCounter::counter_value = %d]", BytecodeCounter::counter_value()); |
|
202 |
} |
|
203 |
} |
|
204 |
||
205 |
||
206 |
// General statistics printing (profiling ...) |
|
207 |
void print_statistics() { |
|
208 |
#ifdef ASSERT |
|
209 |
||
210 |
if (CountRuntimeCalls) { |
|
211 |
extern Histogram *RuntimeHistogram; |
|
212 |
RuntimeHistogram->print(); |
|
213 |
} |
|
214 |
||
215 |
if (CountJNICalls) { |
|
216 |
extern Histogram *JNIHistogram; |
|
217 |
JNIHistogram->print(); |
|
218 |
} |
|
219 |
||
220 |
if (CountJVMCalls) { |
|
221 |
extern Histogram *JVMHistogram; |
|
222 |
JVMHistogram->print(); |
|
223 |
} |
|
224 |
||
225 |
#endif |
|
226 |
||
227 |
if (MemProfiling) { |
|
228 |
MemProfiler::disengage(); |
|
229 |
} |
|
230 |
||
231 |
if (CITime) { |
|
232 |
CompileBroker::print_times(); |
|
233 |
} |
|
234 |
||
235 |
#ifdef COMPILER1 |
|
236 |
if ((PrintC1Statistics || LogVMOutput || LogCompilation) && UseCompiler) { |
|
237 |
FlagSetting fs(DisplayVMOutput, DisplayVMOutput && PrintC1Statistics); |
|
238 |
Runtime1::print_statistics(); |
|
239 |
Deoptimization::print_statistics(); |
|
10254
406448a00c51
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
9992
diff
changeset
|
240 |
SharedRuntime::print_statistics(); |
1 | 241 |
} |
242 |
#endif /* COMPILER1 */ |
|
243 |
||
244 |
#ifdef COMPILER2 |
|
245 |
if ((PrintOptoStatistics || LogVMOutput || LogCompilation) && UseCompiler) { |
|
246 |
FlagSetting fs(DisplayVMOutput, DisplayVMOutput && PrintOptoStatistics); |
|
247 |
Compile::print_statistics(); |
|
248 |
#ifndef COMPILER1 |
|
249 |
Deoptimization::print_statistics(); |
|
10254
406448a00c51
7071427: AdapterFingerPrint can hold 8 entries per int
never
parents:
9992
diff
changeset
|
250 |
SharedRuntime::print_statistics(); |
1 | 251 |
#endif //COMPILER1 |
252 |
os::print_statistics(); |
|
253 |
} |
|
254 |
||
23491 | 255 |
if (PrintLockStatistics || PrintPreciseBiasedLockingStatistics || PrintPreciseRTMLockingStatistics) { |
1 | 256 |
OptoRuntime::print_named_counters(); |
257 |
} |
|
258 |
#ifdef ASSERT |
|
259 |
if (CollectIndexSetStatistics) { |
|
260 |
IndexSet::print_statistics(); |
|
261 |
} |
|
262 |
#endif // ASSERT |
|
49972
37b2446d7f86
8202552: [AOT][JVMCI] Incorrect usage of INCLUDE_JVMCI and INCLUDE_AOT
kvn
parents:
49902
diff
changeset
|
263 |
#else // COMPILER2 |
37b2446d7f86
8202552: [AOT][JVMCI] Incorrect usage of INCLUDE_JVMCI and INCLUDE_AOT
kvn
parents:
49902
diff
changeset
|
264 |
#if INCLUDE_JVMCI |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
265 |
#ifndef COMPILER1 |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
266 |
if ((TraceDeoptimization || LogVMOutput || LogCompilation) && UseCompiler) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
267 |
FlagSetting fs(DisplayVMOutput, DisplayVMOutput && TraceDeoptimization); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
268 |
Deoptimization::print_statistics(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
269 |
SharedRuntime::print_statistics(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
270 |
} |
49972
37b2446d7f86
8202552: [AOT][JVMCI] Incorrect usage of INCLUDE_JVMCI and INCLUDE_AOT
kvn
parents:
49902
diff
changeset
|
271 |
#endif // COMPILER1 |
37b2446d7f86
8202552: [AOT][JVMCI] Incorrect usage of INCLUDE_JVMCI and INCLUDE_AOT
kvn
parents:
49902
diff
changeset
|
272 |
#endif // INCLUDE_JVMCI |
37b2446d7f86
8202552: [AOT][JVMCI] Incorrect usage of INCLUDE_JVMCI and INCLUDE_AOT
kvn
parents:
49902
diff
changeset
|
273 |
#endif // COMPILER2 |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
274 |
|
42650 | 275 |
if (PrintAOTStatistics) { |
276 |
AOTLoader::print_statistics(); |
|
277 |
} |
|
278 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
279 |
if (PrintNMethodStatistics) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
280 |
nmethod::print_statistics(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
281 |
} |
1 | 282 |
if (CountCompiledCalls) { |
283 |
print_method_invocation_histogram(); |
|
284 |
} |
|
23526
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
285 |
|
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
286 |
print_method_profiling_data(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
287 |
|
1 | 288 |
if (TimeOopMap) { |
289 |
GenerateOopMap::print_time(); |
|
290 |
} |
|
291 |
if (PrintSymbolTableSizeHistogram) { |
|
292 |
SymbolTable::print_histogram(); |
|
293 |
} |
|
294 |
if (CountBytecodes || TraceBytecodes || StopInterpreterAt) { |
|
295 |
BytecodeCounter::print(); |
|
296 |
} |
|
297 |
if (PrintBytecodePairHistogram) { |
|
298 |
BytecodePairHistogram::print(); |
|
299 |
} |
|
300 |
||
301 |
if (PrintCodeCache) { |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53750
diff
changeset
|
302 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
1 | 303 |
CodeCache::print(); |
304 |
} |
|
305 |
||
49611 | 306 |
// CodeHeap State Analytics. |
307 |
// Does also call NMethodSweeper::print(tty) |
|
52815
10bb941d7fd4
8214526: Change CodeHeap State Analytics control from UL to Print*
lucy
parents:
52300
diff
changeset
|
308 |
if (PrintCodeHeapAnalytics) { |
55294
3493c1bc59fd
8225388: Running jcmd Compiler.CodeHeap_Analytics all 0 cause crash.
lmesnik
parents:
54927
diff
changeset
|
309 |
CompileBroker::print_heapinfo(NULL, "all", 4096); // details |
49611 | 310 |
} else if (PrintMethodFlushingStatistics) { |
311 |
NMethodSweeper::print(tty); |
|
22210
b0408ba029f6
8025277: Add -XX: flag to print code cache sweeper statistics
anoll
parents:
21095
diff
changeset
|
312 |
} |
b0408ba029f6
8025277: Add -XX: flag to print code cache sweeper statistics
anoll
parents:
21095
diff
changeset
|
313 |
|
1 | 314 |
if (PrintCodeCache2) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53750
diff
changeset
|
315 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
1 | 316 |
CodeCache::print_internals(); |
317 |
} |
|
318 |
||
319 |
if (PrintVtableStats) { |
|
320 |
klassVtable::print_statistics(); |
|
321 |
klassItable::print_statistics(); |
|
322 |
} |
|
51649
8f594f75e054
8187078: -XX:+VerifyOops finds numerous problems when running JPRT
dlong
parents:
51608
diff
changeset
|
323 |
if (VerifyOops && Verbose) { |
1 | 324 |
tty->print_cr("+VerifyOops count: %d", StubRoutines::verify_oop_count()); |
325 |
} |
|
326 |
||
327 |
print_bytecode_count(); |
|
328 |
||
329 |
if (PrintSystemDictionaryAtExit) { |
|
49348
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
48382
diff
changeset
|
330 |
ResourceMark rm; |
51608 | 331 |
MutexLocker mcld(ClassLoaderDataGraph_lock); |
1 | 332 |
SystemDictionary::print(); |
49348
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
48382
diff
changeset
|
333 |
ClassLoaderDataGraph::print(); |
1 | 334 |
} |
335 |
||
31790 | 336 |
if (LogTouchedMethods && PrintTouchedMethodsAtExit) { |
337 |
Method::print_touched_methods(tty); |
|
338 |
} |
|
339 |
||
1 | 340 |
if (PrintBiasedLockingStatistics) { |
341 |
BiasedLocking::print_counters(); |
|
342 |
} |
|
343 |
||
13861
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
344 |
// Native memory tracking data |
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
345 |
if (PrintNMTStatistics) { |
25946 | 346 |
MemTracker::final_report(tty); |
13861
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
347 |
} |
48105
8d15b1369c7a
8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents:
47765
diff
changeset
|
348 |
|
48382
0997d6959851
8193135: get rid of redundant _smr_ prefix/infix in ThreadSMRSupport stuff
dcubed
parents:
48312
diff
changeset
|
349 |
ThreadsSMRSupport::log_statistics(); |
1 | 350 |
} |
351 |
||
352 |
#else // PRODUCT MODE STATISTICS |
|
353 |
||
354 |
void print_statistics() { |
|
355 |
||
23526
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
356 |
if (PrintMethodData) { |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
357 |
print_method_profiling_data(); |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
358 |
} |
6851d341ad52
8037970: make PrintMethodData a diagnostic options
roland
parents:
23491
diff
changeset
|
359 |
|
1 | 360 |
if (CITime) { |
361 |
CompileBroker::print_times(); |
|
362 |
} |
|
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14583
diff
changeset
|
363 |
|
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14583
diff
changeset
|
364 |
if (PrintCodeCache) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
53750
diff
changeset
|
365 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14583
diff
changeset
|
366 |
CodeCache::print(); |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14583
diff
changeset
|
367 |
} |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14583
diff
changeset
|
368 |
|
49611 | 369 |
// CodeHeap State Analytics. |
370 |
// Does also call NMethodSweeper::print(tty) |
|
52815
10bb941d7fd4
8214526: Change CodeHeap State Analytics control from UL to Print*
lucy
parents:
52300
diff
changeset
|
371 |
if (PrintCodeHeapAnalytics) { |
55294
3493c1bc59fd
8225388: Running jcmd Compiler.CodeHeap_Analytics all 0 cause crash.
lmesnik
parents:
54927
diff
changeset
|
372 |
CompileBroker::print_heapinfo(NULL, "all", 4096); // details |
49611 | 373 |
} else if (PrintMethodFlushingStatistics) { |
374 |
NMethodSweeper::print(tty); |
|
22210
b0408ba029f6
8025277: Add -XX: flag to print code cache sweeper statistics
anoll
parents:
21095
diff
changeset
|
375 |
} |
b0408ba029f6
8025277: Add -XX: flag to print code cache sweeper statistics
anoll
parents:
21095
diff
changeset
|
376 |
|
1 | 377 |
#ifdef COMPILER2 |
23491 | 378 |
if (PrintPreciseBiasedLockingStatistics || PrintPreciseRTMLockingStatistics) { |
1 | 379 |
OptoRuntime::print_named_counters(); |
380 |
} |
|
381 |
#endif |
|
382 |
if (PrintBiasedLockingStatistics) { |
|
383 |
BiasedLocking::print_counters(); |
|
384 |
} |
|
13861
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
385 |
|
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
386 |
// Native memory tracking data |
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
387 |
if (PrintNMTStatistics) { |
25946 | 388 |
MemTracker::final_report(tty); |
13861
619cff4bfb8b
7188594: Print statistic collected by NMT with VM flag
zgu
parents:
13728
diff
changeset
|
389 |
} |
31790 | 390 |
|
391 |
if (LogTouchedMethods && PrintTouchedMethodsAtExit) { |
|
392 |
Method::print_touched_methods(tty); |
|
393 |
} |
|
48105
8d15b1369c7a
8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents:
47765
diff
changeset
|
394 |
|
48382
0997d6959851
8193135: get rid of redundant _smr_ prefix/infix in ThreadSMRSupport stuff
dcubed
parents:
48312
diff
changeset
|
395 |
ThreadsSMRSupport::log_statistics(); |
1 | 396 |
} |
397 |
||
398 |
#endif |
|
399 |
||
400 |
// Note: before_exit() can be executed only once, if more than one threads |
|
401 |
// are trying to shutdown the VM at the same time, only one thread |
|
402 |
// can run before_exit() and all other threads must wait. |
|
35143
33daaea9d5c2
8145435: [JVMCI] some tests on Windows fail with: assert(!thread->is_Java_thread()) failed: must not be java thread
twisti
parents:
35061
diff
changeset
|
403 |
void before_exit(JavaThread* thread) { |
1 | 404 |
#define BEFORE_EXIT_NOT_RUN 0 |
405 |
#define BEFORE_EXIT_RUNNING 1 |
|
406 |
#define BEFORE_EXIT_DONE 2 |
|
407 |
static jint volatile _before_exit_status = BEFORE_EXIT_NOT_RUN; |
|
408 |
||
409 |
// Note: don't use a Mutex to guard the entire before_exit(), as |
|
410 |
// JVMTI post_thread_end_event and post_vm_death_event will run native code. |
|
411 |
// A CAS or OSMutex would work just fine but then we need to manipulate |
|
412 |
// thread state for Safepoint. Here we use Monitor wait() and notify_all() |
|
413 |
// for synchronization. |
|
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
414 |
{ MonitorLocker ml(BeforeExit_lock); |
1 | 415 |
switch (_before_exit_status) { |
416 |
case BEFORE_EXIT_NOT_RUN: |
|
417 |
_before_exit_status = BEFORE_EXIT_RUNNING; |
|
418 |
break; |
|
419 |
case BEFORE_EXIT_RUNNING: |
|
420 |
while (_before_exit_status == BEFORE_EXIT_RUNNING) { |
|
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
421 |
ml.wait(); |
1 | 422 |
} |
423 |
assert(_before_exit_status == BEFORE_EXIT_DONE, "invalid state"); |
|
424 |
return; |
|
425 |
case BEFORE_EXIT_DONE: |
|
35914
aab83fe79386
8146616: VM exit path throws fatal error: Thread holding lock at safepoint that vm can block on: BeforeExit_lock
dholmes
parents:
35557
diff
changeset
|
426 |
// need block to avoid SS compiler bug |
aab83fe79386
8146616: VM exit path throws fatal error: Thread holding lock at safepoint that vm can block on: BeforeExit_lock
dholmes
parents:
35557
diff
changeset
|
427 |
{ |
aab83fe79386
8146616: VM exit path throws fatal error: Thread holding lock at safepoint that vm can block on: BeforeExit_lock
dholmes
parents:
35557
diff
changeset
|
428 |
return; |
aab83fe79386
8146616: VM exit path throws fatal error: Thread holding lock at safepoint that vm can block on: BeforeExit_lock
dholmes
parents:
35557
diff
changeset
|
429 |
} |
1 | 430 |
} |
431 |
} |
|
432 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
433 |
#if INCLUDE_JVMCI |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
434 |
JVMCI::shutdown(); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
435 |
#endif |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33063
diff
changeset
|
436 |
|
1 | 437 |
// Hang forever on exit if we're reporting an error. |
46589 | 438 |
if (ShowMessageBoxOnError && VMError::is_error_reported()) { |
1 | 439 |
os::infinite_sleep(); |
440 |
} |
|
441 |
||
39274
940f0e8e9ec2
8158033: Notify_tracing() misplaced for intended purpose
mgronlun
parents:
37248
diff
changeset
|
442 |
EventThreadEnd event; |
940f0e8e9ec2
8158033: Notify_tracing() misplaced for intended purpose
mgronlun
parents:
37248
diff
changeset
|
443 |
if (event.should_commit()) { |
50113 | 444 |
event.set_thread(JFR_THREAD_ID(thread)); |
39274
940f0e8e9ec2
8158033: Notify_tracing() misplaced for intended purpose
mgronlun
parents:
37248
diff
changeset
|
445 |
event.commit(); |
940f0e8e9ec2
8158033: Notify_tracing() misplaced for intended purpose
mgronlun
parents:
37248
diff
changeset
|
446 |
} |
940f0e8e9ec2
8158033: Notify_tracing() misplaced for intended purpose
mgronlun
parents:
37248
diff
changeset
|
447 |
|
50113 | 448 |
JFR_ONLY(Jfr::on_vm_shutdown();) |
39274
940f0e8e9ec2
8158033: Notify_tracing() misplaced for intended purpose
mgronlun
parents:
37248
diff
changeset
|
449 |
|
29321 | 450 |
// Stop the WatcherThread. We do this before disenrolling various |
451 |
// PeriodicTasks to reduce the likelihood of races. |
|
452 |
if (PeriodicTask::num_tasks() > 0) { |
|
6176
4d9030fe341f
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
5924
diff
changeset
|
453 |
WatcherThread::stop(); |
29321 | 454 |
} |
1 | 455 |
|
456 |
// shut down the StatSampler task |
|
457 |
StatSampler::disengage(); |
|
458 |
StatSampler::destroy(); |
|
459 |
||
25070 | 460 |
// Stop concurrent GC threads |
461 |
Universe::heap()->stop(); |
|
1 | 462 |
|
463 |
// Print GC/heap related information. |
|
37242 | 464 |
Log(gc, heap, exit) log; |
35061 | 465 |
if (log.is_info()) { |
466 |
ResourceMark rm; |
|
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46657
diff
changeset
|
467 |
LogStream ls_info(log.info()); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46657
diff
changeset
|
468 |
Universe::print_on(&ls_info); |
35061 | 469 |
if (log.is_trace()) { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46657
diff
changeset
|
470 |
LogStream ls_trace(log.trace()); |
51608 | 471 |
MutexLocker mcld(ClassLoaderDataGraph_lock); |
49348
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
48382
diff
changeset
|
472 |
ClassLoaderDataGraph::print_on(&ls_trace); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13196
diff
changeset
|
473 |
} |
1 | 474 |
} |
475 |
||
476 |
if (PrintBytecodeHistogram) { |
|
477 |
BytecodeHistogram::print(); |
|
478 |
} |
|
479 |
||
480 |
if (JvmtiExport::should_post_thread_life()) { |
|
481 |
JvmtiExport::post_thread_end(thread); |
|
482 |
} |
|
11480
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10739
diff
changeset
|
483 |
|
1 | 484 |
// Always call even when there are not JVMTI environments yet, since environments |
485 |
// may be attached late and JVMTI must track phases of VM execution |
|
486 |
JvmtiExport::post_vm_death(); |
|
487 |
Threads::shutdown_vm_agents(); |
|
488 |
||
489 |
// Terminate the signal thread |
|
490 |
// Note: we don't wait until it actually dies. |
|
491 |
os::terminate_signal_thread(); |
|
492 |
||
54927 | 493 |
#if INCLUDE_CDS |
494 |
if (DynamicDumpSharedSpaces) { |
|
495 |
DynamicArchive::dump(); |
|
496 |
} |
|
497 |
#endif |
|
498 |
||
1 | 499 |
print_statistics(); |
500 |
Universe::heap()->print_tracing_info(); |
|
501 |
||
502 |
{ MutexLocker ml(BeforeExit_lock); |
|
503 |
_before_exit_status = BEFORE_EXIT_DONE; |
|
504 |
BeforeExit_lock->notify_all(); |
|
505 |
} |
|
506 |
||
20053
a12bd7991794
8019835: Strings interned in different threads equal but does not ==
dcubed
parents:
18687
diff
changeset
|
507 |
if (VerifyStringTableAtExit) { |
50445
bd6b78feb6a3
8195097: Make it possible to process StringTable outside safepoint
rehn
parents:
50124
diff
changeset
|
508 |
size_t fail_cnt = StringTable::verify_and_compare_entries(); |
20053
a12bd7991794
8019835: Strings interned in different threads equal but does not ==
dcubed
parents:
18687
diff
changeset
|
509 |
if (fail_cnt != 0) { |
50445
bd6b78feb6a3
8195097: Make it possible to process StringTable outside safepoint
rehn
parents:
50124
diff
changeset
|
510 |
tty->print_cr("ERROR: fail_cnt=" SIZE_FORMAT, fail_cnt); |
20053
a12bd7991794
8019835: Strings interned in different threads equal but does not ==
dcubed
parents:
18687
diff
changeset
|
511 |
guarantee(fail_cnt == 0, "unexpected StringTable verification failures"); |
a12bd7991794
8019835: Strings interned in different threads equal but does not ==
dcubed
parents:
18687
diff
changeset
|
512 |
} |
a12bd7991794
8019835: Strings interned in different threads equal but does not ==
dcubed
parents:
18687
diff
changeset
|
513 |
} |
a12bd7991794
8019835: Strings interned in different threads equal but does not ==
dcubed
parents:
18687
diff
changeset
|
514 |
|
1 | 515 |
#undef BEFORE_EXIT_NOT_RUN |
516 |
#undef BEFORE_EXIT_RUNNING |
|
517 |
#undef BEFORE_EXIT_DONE |
|
518 |
} |
|
519 |
||
520 |
void vm_exit(int code) { |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34230
diff
changeset
|
521 |
Thread* thread = |
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34230
diff
changeset
|
522 |
ThreadLocalStorage::is_initialized() ? Thread::current_or_null() : NULL; |
1 | 523 |
if (thread == NULL) { |
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34230
diff
changeset
|
524 |
// very early initialization failure -- just exit |
1 | 525 |
vm_direct_exit(code); |
526 |
} |
|
527 |
||
54729
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
528 |
// We'd like to add an entry to the XML log to show that the VM is |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
529 |
// terminating, but we can't safely do that here. The logic to make |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
530 |
// XML termination logging safe is tied to the termination of the |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
531 |
// VMThread, and it doesn't terminate on this exit path. See 8222534. |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
532 |
|
1 | 533 |
if (VMThread::vm_thread() != NULL) { |
54729
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
534 |
if (thread->is_Java_thread()) { |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
535 |
// We must be "in_vm" for the code below to work correctly. |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
536 |
// Historically there must have been some exit path for which |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
537 |
// that was not the case and so we set it explicitly - even |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
538 |
// though we no longer know what that path may be. |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
539 |
((JavaThread*)thread)->set_thread_state(_thread_in_vm); |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
540 |
} |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
541 |
|
1 | 542 |
// Fire off a VM_Exit operation to bring VM to a safepoint and exit |
543 |
VM_Exit op(code); |
|
54729
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
544 |
|
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
545 |
// 4945125 The vm thread comes to a safepoint during exit. |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
546 |
// GC vm_operations can get caught at the safepoint, and the |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
547 |
// heap is unparseable if they are caught. Grab the Heap_lock |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
548 |
// to prevent this. The GC vm_operations will not be able to |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
549 |
// queue until after we release it, but we never do that as we |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
550 |
// are terminating the VM process. |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
551 |
MutexLocker ml(Heap_lock); |
f72402697b2f
8222534: VerifyBeforeExit is not honored when System.exit is called
dholmes
parents:
54669
diff
changeset
|
552 |
|
1 | 553 |
VMThread::execute(&op); |
554 |
// should never reach here; but in case something wrong with VM Thread. |
|
555 |
vm_direct_exit(code); |
|
556 |
} else { |
|
557 |
// VM thread is gone, just exit |
|
558 |
vm_direct_exit(code); |
|
559 |
} |
|
560 |
ShouldNotReachHere(); |
|
561 |
} |
|
562 |
||
563 |
void notify_vm_shutdown() { |
|
564 |
// For now, just a dtrace probe. |
|
10739 | 565 |
HOTSPOT_VM_SHUTDOWN(); |
22520
b9e88eed82d7
8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents:
22210
diff
changeset
|
566 |
HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); |
1 | 567 |
} |
568 |
||
569 |
void vm_direct_exit(int code) { |
|
570 |
notify_vm_shutdown(); |
|
8476
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8107
diff
changeset
|
571 |
os::wait_for_keypress_at_exit(); |
26682
f339669ba825
8057744: (process) Synchronize exiting of threads and process [win]
igerasim
parents:
26295
diff
changeset
|
572 |
os::exit(code); |
1 | 573 |
} |
574 |
||
575 |
void vm_perform_shutdown_actions() { |
|
576 |
if (is_init_completed()) { |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34230
diff
changeset
|
577 |
Thread* thread = Thread::current_or_null(); |
7720
8283870fc280
6583275: Hotspot crash in vm_perform_shutdown_actions due to uninitialized TLS during out of memory handling
coleenp
parents:
7397
diff
changeset
|
578 |
if (thread != NULL && thread->is_Java_thread()) { |
1 | 579 |
// We are leaving the VM, set state to native (in case any OS exit |
580 |
// handlers call back to the VM) |
|
581 |
JavaThread* jt = (JavaThread*)thread; |
|
582 |
// Must always be walkable or have no last_Java_frame when in |
|
583 |
// thread_in_native |
|
584 |
jt->frame_anchor()->make_walkable(jt); |
|
585 |
jt->set_thread_state(_thread_in_native); |
|
586 |
} |
|
587 |
} |
|
588 |
notify_vm_shutdown(); |
|
589 |
} |
|
590 |
||
591 |
void vm_shutdown() |
|
592 |
{ |
|
593 |
vm_perform_shutdown_actions(); |
|
8476
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8107
diff
changeset
|
594 |
os::wait_for_keypress_at_exit(); |
1 | 595 |
os::shutdown(); |
596 |
} |
|
597 |
||
773
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
598 |
void vm_abort(bool dump_core) { |
1 | 599 |
vm_perform_shutdown_actions(); |
8476
7e34c2d4cf9b
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
8107
diff
changeset
|
600 |
os::wait_for_keypress_at_exit(); |
33600
922600753f71
8139801: Error message from validation check has wrong order on Windows
sangheki
parents:
33198
diff
changeset
|
601 |
|
922600753f71
8139801: Error message from validation check has wrong order on Windows
sangheki
parents:
33198
diff
changeset
|
602 |
// Flush stdout and stderr before abort. |
922600753f71
8139801: Error message from validation check has wrong order on Windows
sangheki
parents:
33198
diff
changeset
|
603 |
fflush(stdout); |
922600753f71
8139801: Error message from validation check has wrong order on Windows
sangheki
parents:
33198
diff
changeset
|
604 |
fflush(stderr); |
922600753f71
8139801: Error message from validation check has wrong order on Windows
sangheki
parents:
33198
diff
changeset
|
605 |
|
773
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
606 |
os::abort(dump_core); |
1 | 607 |
ShouldNotReachHere(); |
608 |
} |
|
609 |
||
52300
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
610 |
void vm_notify_during_cds_dumping(const char* error, const char* message) { |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
611 |
if (error != NULL) { |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
612 |
tty->print_cr("Error occurred during CDS dumping"); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
613 |
tty->print("%s", error); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
614 |
if (message != NULL) { |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
615 |
tty->print_cr(": %s", message); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
616 |
} |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
617 |
else { |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
618 |
tty->cr(); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
619 |
} |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
620 |
} |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
621 |
} |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
622 |
|
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
623 |
void vm_exit_during_cds_dumping(const char* error, const char* message) { |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
624 |
vm_notify_during_cds_dumping(error, message); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
625 |
|
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
626 |
// Failure during CDS dumping, we don't want to dump core |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
627 |
vm_abort(false); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
628 |
} |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52097
diff
changeset
|
629 |
|
1 | 630 |
void vm_notify_during_shutdown(const char* error, const char* message) { |
631 |
if (error != NULL) { |
|
632 |
tty->print_cr("Error occurred during initialization of VM"); |
|
633 |
tty->print("%s", error); |
|
634 |
if (message != NULL) { |
|
635 |
tty->print_cr(": %s", message); |
|
636 |
} |
|
637 |
else { |
|
638 |
tty->cr(); |
|
639 |
} |
|
640 |
} |
|
641 |
if (ShowMessageBoxOnError && WizardMode) { |
|
642 |
fatal("Error occurred during initialization of VM"); |
|
643 |
} |
|
644 |
} |
|
645 |
||
44326
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
646 |
void vm_exit_during_initialization() { |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
647 |
vm_notify_during_shutdown(NULL, NULL); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
648 |
|
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
649 |
// Failure during initialization, we don't want to dump core |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
650 |
vm_abort(false); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
651 |
} |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
42650
diff
changeset
|
652 |
|
1 | 653 |
void vm_exit_during_initialization(Handle exception) { |
654 |
tty->print_cr("Error occurred during initialization of VM"); |
|
655 |
// If there are exceptions on this thread it must be cleared |
|
656 |
// first and here. Any future calls to EXCEPTION_MARK requires |
|
657 |
// that no pending exceptions exist. |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
34230
diff
changeset
|
658 |
Thread *THREAD = Thread::current(); // can't be NULL |
1 | 659 |
if (HAS_PENDING_EXCEPTION) { |
660 |
CLEAR_PENDING_EXCEPTION; |
|
661 |
} |
|
35143
33daaea9d5c2
8145435: [JVMCI] some tests on Windows fail with: assert(!thread->is_Java_thread()) failed: must not be java thread
twisti
parents:
35061
diff
changeset
|
662 |
java_lang_Throwable::print_stack_trace(exception, tty); |
1 | 663 |
tty->cr(); |
664 |
vm_notify_during_shutdown(NULL, NULL); |
|
773
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
665 |
|
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
666 |
// Failure during initialization, we don't want to dump core |
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
667 |
vm_abort(false); |
1 | 668 |
} |
669 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7900
diff
changeset
|
670 |
void vm_exit_during_initialization(Symbol* ex, const char* message) { |
1 | 671 |
ResourceMark rm; |
672 |
vm_notify_during_shutdown(ex->as_C_string(), message); |
|
773
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
673 |
|
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
674 |
// Failure during initialization, we don't want to dump core |
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
675 |
vm_abort(false); |
1 | 676 |
} |
677 |
||
678 |
void vm_exit_during_initialization(const char* error, const char* message) { |
|
679 |
vm_notify_during_shutdown(error, message); |
|
773
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
680 |
|
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
681 |
// Failure during initialization, we don't want to dump core |
01daf7c809b1
6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents:
234
diff
changeset
|
682 |
vm_abort(false); |
1 | 683 |
} |
684 |
||
685 |
void vm_shutdown_during_initialization(const char* error, const char* message) { |
|
686 |
vm_notify_during_shutdown(error, message); |
|
687 |
vm_shutdown(); |
|
688 |
} |
|
689 |
||
950 | 690 |
JDK_Version JDK_Version::_current; |
13106 | 691 |
const char* JDK_Version::_runtime_name; |
14289
aec758622b4b
8002078: hs_err_pid file should report full JDK version string
sla
parents:
13861
diff
changeset
|
692 |
const char* JDK_Version::_runtime_version; |
1 | 693 |
|
694 |
void JDK_Version::initialize() { |
|
950 | 695 |
jdk_version_info info; |
696 |
assert(!_current.is_valid(), "Don't initialize twice"); |
|
697 |
||
1 | 698 |
void *lib_handle = os::native_java_library(); |
950 | 699 |
jdk_version_info_fn_t func = CAST_TO_FN_PTR(jdk_version_info_fn_t, |
700 |
os::dll_lookup(lib_handle, "JDK_GetVersionInfo0")); |
|
1 | 701 |
|
33959
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
702 |
assert(func != NULL, "Support for JDK 1.5 or older has been removed after JEP-223"); |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
703 |
|
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
704 |
(*func)(&info, sizeof(info)); |
1 | 705 |
|
33959
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
706 |
int major = JDK_VERSION_MAJOR(info.jdk_version); |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
707 |
int minor = JDK_VERSION_MINOR(info.jdk_version); |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
708 |
int security = JDK_VERSION_SECURITY(info.jdk_version); |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
709 |
int build = JDK_VERSION_BUILD(info.jdk_version); |
1 | 710 |
|
54795
fd08f5a976e6
8189208: Cleanup ancient argument processing code
gziemski
parents:
54786
diff
changeset
|
711 |
_current = JDK_Version(major, minor, security, info.patch_version, build); |
1 | 712 |
} |
713 |
||
714 |
void JDK_Version_init() { |
|
715 |
JDK_Version::initialize(); |
|
716 |
} |
|
950 | 717 |
|
718 |
static int64_t encode_jdk_version(const JDK_Version& v) { |
|
719 |
return |
|
33959
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
720 |
((int64_t)v.major_version() << (BitsPerByte * 4)) | |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
721 |
((int64_t)v.minor_version() << (BitsPerByte * 3)) | |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
722 |
((int64_t)v.security_version() << (BitsPerByte * 2)) | |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
723 |
((int64_t)v.patch_version() << (BitsPerByte * 1)) | |
950 | 724 |
((int64_t)v.build_number() << (BitsPerByte * 0)); |
725 |
} |
|
726 |
||
727 |
int JDK_Version::compare(const JDK_Version& other) const { |
|
728 |
assert(is_valid() && other.is_valid(), "Invalid version (uninitialized?)"); |
|
33959
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
729 |
uint64_t e = encode_jdk_version(*this); |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
730 |
uint64_t o = encode_jdk_version(other); |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
731 |
return (e > o) ? 1 : ((e == o) ? 0 : -1); |
950 | 732 |
} |
733 |
||
734 |
void JDK_Version::to_string(char* buffer, size_t buflen) const { |
|
27471 | 735 |
assert(buffer && buflen > 0, "call with useful buffer"); |
950 | 736 |
size_t index = 0; |
27471 | 737 |
|
950 | 738 |
if (!is_valid()) { |
739 |
jio_snprintf(buffer, buflen, "%s", "(uninitialized)"); |
|
740 |
} else { |
|
27471 | 741 |
int rc = jio_snprintf( |
950 | 742 |
&buffer[index], buflen - index, "%d.%d", _major, _minor); |
27471 | 743 |
if (rc == -1) return; |
744 |
index += rc; |
|
33957
39113ae98993
8085822: JEP 223: New Version-String Scheme (initial integration)
ihse
parents:
30764
diff
changeset
|
745 |
if (_security > 0) { |
39113ae98993
8085822: JEP 223: New Version-String Scheme (initial integration)
ihse
parents:
30764
diff
changeset
|
746 |
rc = jio_snprintf(&buffer[index], buflen - index, ".%d", _security); |
46293
9a88f7fe04b5
8167423: Adding return value check and updating index variable
shshahma
parents:
46271
diff
changeset
|
747 |
if (rc == -1) return; |
9a88f7fe04b5
8167423: Adding return value check and updating index variable
shshahma
parents:
46271
diff
changeset
|
748 |
index += rc; |
950 | 749 |
} |
33959
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
750 |
if (_patch > 0) { |
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
751 |
rc = jio_snprintf(&buffer[index], buflen - index, ".%d", _patch); |
27471 | 752 |
if (rc == -1) return; |
753 |
index += rc; |
|
950 | 754 |
} |
755 |
if (_build > 0) { |
|
33959
36f534ca18c0
8087202: Add support for PATCH field and remove unused fields of new version string
amurillo
parents:
33957
diff
changeset
|
756 |
rc = jio_snprintf(&buffer[index], buflen - index, "+%d", _build); |
27471 | 757 |
if (rc == -1) return; |
758 |
index += rc; |
|
950 | 759 |
} |
760 |
} |
|
761 |
} |