author | kvn |
Wed, 01 May 2019 12:31:29 -0700 | |
changeset 54669 | ad45b3802d4e |
parent 54645 | 05aaccf7d558 |
child 54732 | 2d012a75d35c |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53353 | 2 |
* Copyright (c) 1999, 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:
5533
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5533
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:
5533
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:
47687
diff
changeset
|
26 |
#include "jvm.h" |
35135 | 27 |
#include "classfile/symbolTable.hpp" |
7397 | 28 |
#include "classfile/systemDictionary.hpp" |
29 |
#include "classfile/vmSymbols.hpp" |
|
30 |
#include "code/codeCache.hpp" |
|
49611 | 31 |
#include "code/codeHeapState.hpp" |
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
34191
diff
changeset
|
32 |
#include "code/dependencyContext.hpp" |
7397 | 33 |
#include "compiler/compileBroker.hpp" |
34 |
#include "compiler/compileLog.hpp" |
|
35 |
#include "compiler/compilerOracle.hpp" |
|
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
36 |
#include "compiler/directivesParser.hpp" |
7397 | 37 |
#include "interpreter/linkResolver.hpp" |
50113 | 38 |
#include "jfr/jfrEvents.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46632
diff
changeset
|
39 |
#include "logging/log.hpp" |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46632
diff
changeset
|
40 |
#include "logging/logStream.hpp" |
7397 | 41 |
#include "memory/allocation.inline.hpp" |
37248 | 42 |
#include "memory/resourceArea.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
43 |
#include "oops/methodData.hpp" |
49340
4e82736053ae
8191102: Incorrect include file use in classLoader.hpp
hseigel
parents:
48400
diff
changeset
|
44 |
#include "oops/method.inline.hpp" |
7397 | 45 |
#include "oops/oop.inline.hpp" |
46 |
#include "prims/nativeLookup.hpp" |
|
27642
8c9eff693145
8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents:
27464
diff
changeset
|
47 |
#include "prims/whitebox.hpp" |
7397 | 48 |
#include "runtime/arguments.hpp" |
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
40074
diff
changeset
|
49 |
#include "runtime/atomic.hpp" |
7397 | 50 |
#include "runtime/compilationPolicy.hpp" |
53582 | 51 |
#include "runtime/handles.inline.hpp" |
7397 | 52 |
#include "runtime/init.hpp" |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49340
diff
changeset
|
53 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 54 |
#include "runtime/javaCalls.hpp" |
49848 | 55 |
#include "runtime/jniHandles.inline.hpp" |
7397 | 56 |
#include "runtime/os.hpp" |
49594
898ef81cbc0e
8200106: Move NoSafepointVerifier out from gcLocker.hpp
stefank
parents:
49480
diff
changeset
|
57 |
#include "runtime/safepointVerifiers.hpp" |
7397 | 58 |
#include "runtime/sharedRuntime.hpp" |
59 |
#include "runtime/sweeper.hpp" |
|
37161
e881f320966e
8150015: Integrate TraceTime with Unified Logging more seamlessly
rehn
parents:
37129
diff
changeset
|
60 |
#include "runtime/timerTrace.hpp" |
49480
d7df2dd501ce
8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents:
49469
diff
changeset
|
61 |
#include "runtime/vframe.inline.hpp" |
46560
388aa8d67c80
8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents:
46485
diff
changeset
|
62 |
#include "utilities/debug.hpp" |
7397 | 63 |
#include "utilities/dtrace.hpp" |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
64 |
#include "utilities/events.hpp" |
46560
388aa8d67c80
8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents:
46485
diff
changeset
|
65 |
#include "utilities/formatBuffer.hpp" |
50113 | 66 |
#include "utilities/macros.hpp" |
7397 | 67 |
#ifdef COMPILER1 |
68 |
#include "c1/c1_Compiler.hpp" |
|
69 |
#endif |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
70 |
#if INCLUDE_JVMCI |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
71 |
#include "jvmci/jvmciEnv.hpp" |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
72 |
#include "jvmci/jvmciRuntime.hpp" |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
73 |
#include "runtime/vframe.hpp" |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
74 |
#endif |
7397 | 75 |
#ifdef COMPILER2 |
76 |
#include "opto/c2compiler.hpp" |
|
77 |
#endif |
|
1 | 78 |
|
79 |
#ifdef DTRACE_ENABLED |
|
80 |
||
81 |
// Only bother with this argument setup if dtrace is available |
|
82 |
||
17133
ef4dd2f8fcb1
8013532: Remove unused parameter "compiler" from DTRACE_METHOD_COMPILE* macros
roland
parents:
17132
diff
changeset
|
83 |
#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name) \ |
10739 | 84 |
{ \ |
85 |
Symbol* klass_name = (method)->klass_name(); \ |
|
86 |
Symbol* name = (method)->name(); \ |
|
87 |
Symbol* signature = (method)->signature(); \ |
|
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
88 |
HOTSPOT_METHOD_COMPILE_BEGIN( \ |
22520
b9e88eed82d7
8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents:
22247
diff
changeset
|
89 |
(char *) comp_name, strlen(comp_name), \ |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
90 |
(char *) klass_name->bytes(), klass_name->utf8_length(), \ |
10739 | 91 |
(char *) name->bytes(), name->utf8_length(), \ |
92 |
(char *) signature->bytes(), signature->utf8_length()); \ |
|
93 |
} |
|
94 |
||
17133
ef4dd2f8fcb1
8013532: Remove unused parameter "compiler" from DTRACE_METHOD_COMPILE* macros
roland
parents:
17132
diff
changeset
|
95 |
#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success) \ |
10739 | 96 |
{ \ |
97 |
Symbol* klass_name = (method)->klass_name(); \ |
|
98 |
Symbol* name = (method)->name(); \ |
|
99 |
Symbol* signature = (method)->signature(); \ |
|
100 |
HOTSPOT_METHOD_COMPILE_END( \ |
|
22520
b9e88eed82d7
8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents:
22247
diff
changeset
|
101 |
(char *) comp_name, strlen(comp_name), \ |
10739 | 102 |
(char *) klass_name->bytes(), klass_name->utf8_length(), \ |
103 |
(char *) name->bytes(), name->utf8_length(), \ |
|
104 |
(char *) signature->bytes(), signature->utf8_length(), (success)); \ |
|
105 |
} |
|
106 |
||
1 | 107 |
#else // ndef DTRACE_ENABLED |
108 |
||
17133
ef4dd2f8fcb1
8013532: Remove unused parameter "compiler" from DTRACE_METHOD_COMPILE* macros
roland
parents:
17132
diff
changeset
|
109 |
#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name) |
ef4dd2f8fcb1
8013532: Remove unused parameter "compiler" from DTRACE_METHOD_COMPILE* macros
roland
parents:
17132
diff
changeset
|
110 |
#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success) |
1 | 111 |
|
112 |
#endif // ndef DTRACE_ENABLED |
|
113 |
||
114 |
bool CompileBroker::_initialized = false; |
|
115 |
volatile bool CompileBroker::_should_block = false; |
|
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47687
diff
changeset
|
116 |
volatile int CompileBroker::_print_compilation_warning = 0; |
4750 | 117 |
volatile jint CompileBroker::_should_compile_new_jobs = run_compilation; |
1 | 118 |
|
119 |
// The installed compiler(s) |
|
120 |
AbstractCompiler* CompileBroker::_compilers[2]; |
|
121 |
||
49848 | 122 |
// The maximum numbers of compiler threads to be determined during startup. |
123 |
int CompileBroker::_c1_count = 0; |
|
124 |
int CompileBroker::_c2_count = 0; |
|
125 |
||
126 |
// An array of compiler names as Java String objects |
|
127 |
jobject* CompileBroker::_compiler1_objects = NULL; |
|
128 |
jobject* CompileBroker::_compiler2_objects = NULL; |
|
129 |
||
130 |
CompileLog** CompileBroker::_compiler1_logs = NULL; |
|
131 |
CompileLog** CompileBroker::_compiler2_logs = NULL; |
|
132 |
||
22247 | 133 |
// These counters are used to assign an unique ID to each compilation. |
134 |
volatile jint CompileBroker::_compilation_id = 0; |
|
135 |
volatile jint CompileBroker::_osr_compilation_id = 0; |
|
1 | 136 |
|
137 |
// Performance counters |
|
138 |
PerfCounter* CompileBroker::_perf_total_compilation = NULL; |
|
139 |
PerfCounter* CompileBroker::_perf_osr_compilation = NULL; |
|
140 |
PerfCounter* CompileBroker::_perf_standard_compilation = NULL; |
|
141 |
||
142 |
PerfCounter* CompileBroker::_perf_total_bailout_count = NULL; |
|
143 |
PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL; |
|
144 |
PerfCounter* CompileBroker::_perf_total_compile_count = NULL; |
|
145 |
PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL; |
|
146 |
PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL; |
|
147 |
||
148 |
PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL; |
|
149 |
PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL; |
|
150 |
PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL; |
|
151 |
PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL; |
|
152 |
||
153 |
PerfStringVariable* CompileBroker::_perf_last_method = NULL; |
|
154 |
PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL; |
|
155 |
PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL; |
|
156 |
PerfVariable* CompileBroker::_perf_last_compile_type = NULL; |
|
157 |
PerfVariable* CompileBroker::_perf_last_compile_size = NULL; |
|
158 |
PerfVariable* CompileBroker::_perf_last_failed_type = NULL; |
|
159 |
PerfVariable* CompileBroker::_perf_last_invalidated_type = NULL; |
|
160 |
||
161 |
// Timers and counters for generating statistics |
|
162 |
elapsedTimer CompileBroker::_t_total_compilation; |
|
163 |
elapsedTimer CompileBroker::_t_osr_compilation; |
|
164 |
elapsedTimer CompileBroker::_t_standard_compilation; |
|
26913 | 165 |
elapsedTimer CompileBroker::_t_invalidated_compilation; |
166 |
elapsedTimer CompileBroker::_t_bailedout_compilation; |
|
1 | 167 |
|
50515
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
168 |
int CompileBroker::_total_bailout_count = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
169 |
int CompileBroker::_total_invalidated_count = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
170 |
int CompileBroker::_total_compile_count = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
171 |
int CompileBroker::_total_osr_compile_count = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
172 |
int CompileBroker::_total_standard_compile_count = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
173 |
int CompileBroker::_total_compiler_stopped_count = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
174 |
int CompileBroker::_total_compiler_restarted_count = 0; |
1 | 175 |
|
50515
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
176 |
int CompileBroker::_sum_osr_bytes_compiled = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
177 |
int CompileBroker::_sum_standard_bytes_compiled = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
178 |
int CompileBroker::_sum_nmethod_size = 0; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
179 |
int CompileBroker::_sum_nmethod_code_size = 0; |
1 | 180 |
|
50515
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
181 |
long CompileBroker::_peak_compilation_time = 0; |
18025 | 182 |
|
50515
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
183 |
CompileQueue* CompileBroker::_c2_compile_queue = NULL; |
1ce463f497ad
8204476: Add additional statistics to CodeCache::print_summary
goetz
parents:
50217
diff
changeset
|
184 |
CompileQueue* CompileBroker::_c1_compile_queue = NULL; |
1 | 185 |
|
38218 | 186 |
|
187 |
||
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
188 |
class CompilationLog : public StringEventLog { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
189 |
public: |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
190 |
CompilationLog() : StringEventLog("Compilation events") { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
191 |
} |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
192 |
|
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
193 |
void log_compile(JavaThread* thread, CompileTask* task) { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
194 |
StringLogMessage lm; |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
195 |
stringStream sstr = lm.stream(); |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
196 |
// msg.time_stamp().update_to(tty->time_stamp().ticks()); |
32582
56619bb8bcaa
8135067: Preparatory refactorings for compiler control
neliasso
parents:
32391
diff
changeset
|
197 |
task->print(&sstr, NULL, true, false); |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
198 |
log(thread, "%s", (const char*)lm); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
199 |
} |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
200 |
|
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
201 |
void log_nmethod(JavaThread* thread, nmethod* nm) { |
31592
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
28650
diff
changeset
|
202 |
log(thread, "nmethod %d%s " INTPTR_FORMAT " code [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", |
11788 | 203 |
nm->compile_id(), nm->is_osr_method() ? "%" : "", |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24350
diff
changeset
|
204 |
p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end())); |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
205 |
} |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
206 |
|
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
207 |
void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
208 |
StringLogMessage lm; |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
209 |
lm.print("%4d COMPILE SKIPPED: %s", task->compile_id(), reason); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
210 |
if (retry_message != NULL) { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
211 |
lm.append(" (%s)", retry_message); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
212 |
} |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
213 |
lm.print("\n"); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
214 |
log(thread, "%s", (const char*)lm); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
215 |
} |
27461
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
216 |
|
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
217 |
void log_metaspace_failure(const char* reason) { |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
218 |
ResourceMark rm; |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
219 |
StringLogMessage lm; |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
220 |
lm.print("%4d COMPILE PROFILING SKIPPED: %s", -1, reason); |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
221 |
lm.print("\n"); |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
222 |
log(JavaThread::current(), "%s", (const char*)lm); |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
223 |
} |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
224 |
}; |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
225 |
|
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
226 |
static CompilationLog* _compilation_log = NULL; |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
227 |
|
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
228 |
bool compileBroker_init() { |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
229 |
if (LogEvents) { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
230 |
_compilation_log = new CompilationLog(); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
231 |
} |
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
232 |
|
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
233 |
// init directives stack, adding default directive |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
234 |
DirectivesStack::init(); |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
235 |
|
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
236 |
if (DirectivesParser::has_file()) { |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
237 |
return DirectivesParser::parse_from_flag(); |
35129
8b93709bf4e5
8144246: adding lots of directives via jcmd may produce OOM crash
neliasso
parents:
35114
diff
changeset
|
238 |
} else if (CompilerDirectivesPrint) { |
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
239 |
// Print default directive even when no other was added |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
240 |
DirectivesStack::print(tty); |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
241 |
} |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
242 |
|
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
243 |
return true; |
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
244 |
} |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
245 |
|
1 | 246 |
CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) { |
247 |
CompilerThread* thread = CompilerThread::current(); |
|
248 |
thread->set_task(task); |
|
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
249 |
#if INCLUDE_JVMCI |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
250 |
if (task->is_blocking() && CompileBroker::compiler(task->comp_level())->is_jvmci()) { |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
251 |
task->set_jvmci_compiler_thread(thread); |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
252 |
} |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
253 |
#endif |
1 | 254 |
CompileLog* log = thread->log(); |
54015
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
255 |
if (log != NULL && !task->is_unloaded()) task->log_task_start(log); |
1 | 256 |
} |
257 |
||
258 |
CompileTaskWrapper::~CompileTaskWrapper() { |
|
259 |
CompilerThread* thread = CompilerThread::current(); |
|
260 |
CompileTask* task = thread->task(); |
|
261 |
CompileLog* log = thread->log(); |
|
54015
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
262 |
if (log != NULL && !task->is_unloaded()) task->log_task_done(log); |
1 | 263 |
thread->set_task(NULL); |
264 |
task->set_code_handle(NULL); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
265 |
thread->set_env(NULL); |
1 | 266 |
if (task->is_blocking()) { |
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
267 |
bool free_task = false; |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
268 |
{ |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
269 |
MutexLocker notifier(task->lock(), thread); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
270 |
task->mark_complete(); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
271 |
#if INCLUDE_JVMCI |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
272 |
if (CompileBroker::compiler(task->comp_level())->is_jvmci()) { |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
273 |
if (!task->has_waiter()) { |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
274 |
// The waiting thread timed out and thus did not free the task. |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
275 |
free_task = true; |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
276 |
} |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
277 |
task->set_jvmci_compiler_thread(NULL); |
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
278 |
} |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
279 |
#endif |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
280 |
if (!free_task) { |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
281 |
// Notify the waiting thread that the compilation has completed |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
282 |
// so that it can free the task. |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
283 |
task->lock()->notify_all(); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
284 |
} |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
285 |
} |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
286 |
if (free_task) { |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
287 |
// The task can only be freed once the task lock is released. |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
288 |
CompileTask::free(task); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
289 |
} |
1 | 290 |
} else { |
291 |
task->mark_complete(); |
|
292 |
||
293 |
// By convention, the compiling thread is responsible for |
|
294 |
// recycling a non-blocking CompileTask. |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
295 |
CompileTask::free(task); |
1 | 296 |
} |
297 |
} |
|
298 |
||
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
299 |
/** |
49848 | 300 |
* Check if a CompilerThread can be removed and update count if requested. |
301 |
*/ |
|
302 |
static bool can_remove(CompilerThread *ct, bool do_it) { |
|
303 |
assert(UseDynamicNumberOfCompilerThreads, "or shouldn't be here"); |
|
304 |
if (!ReduceNumberOfCompilerThreads) return false; |
|
305 |
||
306 |
AbstractCompiler *compiler = ct->compiler(); |
|
307 |
int compiler_count = compiler->num_compiler_threads(); |
|
308 |
bool c1 = compiler->is_c1(); |
|
309 |
||
310 |
// Keep at least 1 compiler thread of each type. |
|
311 |
if (compiler_count < 2) return false; |
|
312 |
||
313 |
// Keep thread alive for at least some time. |
|
314 |
if (ct->idle_time_millis() < (c1 ? 500 : 100)) return false; |
|
315 |
||
316 |
// We only allow the last compiler thread of each type to get removed. |
|
317 |
jobject last_compiler = c1 ? CompileBroker::compiler1_object(compiler_count - 1) |
|
318 |
: CompileBroker::compiler2_object(compiler_count - 1); |
|
319 |
if (oopDesc::equals(ct->threadObj(), JNIHandles::resolve_non_null(last_compiler))) { |
|
320 |
if (do_it) { |
|
321 |
assert_locked_or_safepoint(CompileThread_lock); // Update must be consistent. |
|
322 |
compiler->set_num_compiler_threads(compiler_count - 1); |
|
323 |
} |
|
324 |
return true; |
|
325 |
} |
|
326 |
return false; |
|
327 |
} |
|
328 |
||
329 |
/** |
|
25343
d1dcc8376d83
8046286: assert: Do not add task if compilation is turned off forever
anoll
parents:
24443
diff
changeset
|
330 |
* Add a CompileTask to a CompileQueue. |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
331 |
*/ |
1 | 332 |
void CompileQueue::add(CompileTask* task) { |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
333 |
assert(MethodCompileQueue_lock->owned_by_self(), "must own lock"); |
1 | 334 |
|
335 |
task->set_next(NULL); |
|
6453 | 336 |
task->set_prev(NULL); |
1 | 337 |
|
338 |
if (_last == NULL) { |
|
339 |
// The compile queue is empty. |
|
340 |
assert(_first == NULL, "queue is empty"); |
|
341 |
_first = task; |
|
342 |
_last = task; |
|
343 |
} else { |
|
344 |
// Append the task to the queue. |
|
345 |
assert(_last->next() == NULL, "not last"); |
|
346 |
_last->set_next(task); |
|
6453 | 347 |
task->set_prev(_last); |
1 | 348 |
_last = task; |
349 |
} |
|
6453 | 350 |
++_size; |
1 | 351 |
|
352 |
// Mark the method as being in the compile queue. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
353 |
task->method()->set_queued_for_compilation(); |
1 | 354 |
|
26587 | 355 |
if (CIPrintCompileQueue) { |
356 |
print_tty(); |
|
357 |
} |
|
1 | 358 |
|
359 |
if (LogCompilation && xtty != NULL) { |
|
360 |
task->log_task_queued(); |
|
361 |
} |
|
362 |
||
363 |
// Notify CompilerThreads that a task is available. |
|
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
364 |
MethodCompileQueue_lock->notify_all(); |
1 | 365 |
} |
366 |
||
24346
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
367 |
/** |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
368 |
* Empties compilation queue by putting all compilation tasks onto |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
369 |
* a freelist. Furthermore, the method wakes up all threads that are |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
370 |
* waiting on a compilation task to finish. This can happen if background |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
371 |
* compilation is disabled. |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
372 |
*/ |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
373 |
void CompileQueue::free_all() { |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
374 |
MutexLocker mu(MethodCompileQueue_lock); |
24346
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
375 |
CompileTask* next = _first; |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
376 |
|
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
377 |
// Iterate over all tasks in the compile queue |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
378 |
while (next != NULL) { |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
379 |
CompileTask* current = next; |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
380 |
next = current->next(); |
25339
ca74d9691341
8043158: Crash in CodeSweeperSweepNoFlushTest in CompileQueue::free_all()
anoll
parents:
24443
diff
changeset
|
381 |
{ |
ca74d9691341
8043158: Crash in CodeSweeperSweepNoFlushTest in CompileQueue::free_all()
anoll
parents:
24443
diff
changeset
|
382 |
// Wake up thread that blocks on the compile task. |
ca74d9691341
8043158: Crash in CodeSweeperSweepNoFlushTest in CompileQueue::free_all()
anoll
parents:
24443
diff
changeset
|
383 |
MutexLocker ct_lock(current->lock()); |
ca74d9691341
8043158: Crash in CodeSweeperSweepNoFlushTest in CompileQueue::free_all()
anoll
parents:
24443
diff
changeset
|
384 |
current->lock()->notify(); |
ca74d9691341
8043158: Crash in CodeSweeperSweepNoFlushTest in CompileQueue::free_all()
anoll
parents:
24443
diff
changeset
|
385 |
} |
24346
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
386 |
// Put the task back on the freelist. |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
387 |
CompileTask::free(current); |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
388 |
} |
24346
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
389 |
_first = NULL; |
46eee6f68757
8042428: CompileQueue::free_all() code is incorrect
anoll
parents:
24321
diff
changeset
|
390 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
391 |
// Wake up all threads that block on the queue. |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
392 |
MethodCompileQueue_lock->notify_all(); |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
393 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
394 |
|
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
395 |
/** |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
396 |
* Get the next CompileTask from a CompileQueue |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
397 |
*/ |
1 | 398 |
CompileTask* CompileQueue::get() { |
31981
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
399 |
// save methods from RedefineClasses across safepoint |
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
400 |
// across MethodCompileQueue_lock below. |
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
401 |
methodHandle save_method; |
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
402 |
methodHandle save_hot_method; |
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
403 |
|
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
404 |
MonitorLocker locker(MethodCompileQueue_lock); |
20290
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
405 |
// If _first is NULL we have no more compile jobs. There are two reasons for |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
406 |
// having no compile jobs: First, we compiled everything we wanted. Second, |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
407 |
// we ran out of code cache so compilation has been disabled. In the latter |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
408 |
// case we perform code cache sweeps to free memory such that we can re-enable |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
409 |
// compilation. |
1 | 410 |
while (_first == NULL) { |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
411 |
// Exit loop if compilation is disabled forever |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
412 |
if (CompileBroker::is_compilation_disabled_forever()) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
413 |
return NULL; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
414 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
415 |
|
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
416 |
// If there are no compilation tasks and we can compile new jobs |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
417 |
// (i.e., there is enough free space in the code cache) there is |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
418 |
// no need to invoke the sweeper. As a result, the hotness of methods |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
419 |
// remains unchanged. This behavior is desired, since we want to keep |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
420 |
// the stable state, i.e., we do not want to evict methods from the |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
421 |
// code cache if it is unnecessary. |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
422 |
// We need a timed wait here, since compiler threads can exit if compilation |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
423 |
// is disabled forever. We use 5 seconds wait time; the exiting of compiler threads |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
424 |
// is not critical and we do not want idle compiler threads to wake up too often. |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
425 |
locker.wait(5*1000); |
49848 | 426 |
|
427 |
if (UseDynamicNumberOfCompilerThreads && _first == NULL) { |
|
428 |
// Still nothing to compile. Give caller a chance to stop this thread. |
|
429 |
if (can_remove(CompilerThread::current(), false)) return NULL; |
|
430 |
} |
|
1 | 431 |
} |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
432 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
433 |
if (CompileBroker::is_compilation_disabled_forever()) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
434 |
return NULL; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
435 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
436 |
|
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
437 |
CompileTask* task; |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
438 |
{ |
35492
c8c0273e6b91
8146690: Make all classes in GC follow the naming convention.
david
parents:
34196
diff
changeset
|
439 |
NoSafepointVerifier nsv; |
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
440 |
task = CompilationPolicy::policy()->select_task(this); |
54015
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
441 |
if (task != NULL) { |
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
442 |
task = task->select_for_compilation(); |
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
443 |
} |
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
444 |
} |
31981
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
445 |
|
37281
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
446 |
if (task != NULL) { |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
447 |
// Save method pointers across unlock safepoint. The task is removed from |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
448 |
// the compilation queue, which is walked during RedefineClasses. |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
449 |
save_method = methodHandle(task->method()); |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
450 |
save_hot_method = methodHandle(task->hot_method()); |
31981
9caa094a485f
8082782: vm crash on StressRedefineWithoutBytecodeCorruption fails with assert(((Metadata*)obj)->is_valid()) failed: obj is valid
coleenp
parents:
31775
diff
changeset
|
451 |
|
37281
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
452 |
remove(task); |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
453 |
purge_stale_tasks(); // may temporarily release MCQ lock |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
454 |
} |
6453 | 455 |
return task; |
456 |
} |
|
1 | 457 |
|
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
458 |
// Clean & deallocate stale compile tasks. |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
459 |
// Temporarily releases MethodCompileQueue lock. |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
460 |
void CompileQueue::purge_stale_tasks() { |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
461 |
assert(MethodCompileQueue_lock->owned_by_self(), "must own lock"); |
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
462 |
if (_first_stale != NULL) { |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
463 |
// Stale tasks are purged when MCQ lock is released, |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
464 |
// but _first_stale updates are protected by MCQ lock. |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
465 |
// Once task processing starts and MCQ lock is released, |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
466 |
// other compiler threads can reuse _first_stale. |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
467 |
CompileTask* head = _first_stale; |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
468 |
_first_stale = NULL; |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
469 |
{ |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
470 |
MutexUnlocker ul(MethodCompileQueue_lock); |
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
471 |
for (CompileTask* task = head; task != NULL; ) { |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
472 |
CompileTask* next_task = task->next(); |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
473 |
CompileTaskWrapper ctw(task); // Frees the task |
25642
9d809ea074d9
8049530: Provide descriptive failure reason for compilation tasks removed for the queue
vlivanov
parents:
25477
diff
changeset
|
474 |
task->set_failure_reason("stale task"); |
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
475 |
task = next_task; |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
476 |
} |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
477 |
} |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
478 |
} |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
479 |
} |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
480 |
|
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
481 |
void CompileQueue::remove(CompileTask* task) { |
54015
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
482 |
assert(MethodCompileQueue_lock->owned_by_self(), "must own lock"); |
6453 | 483 |
if (task->prev() != NULL) { |
484 |
task->prev()->set_next(task->next()); |
|
485 |
} else { |
|
486 |
// max is the first element |
|
487 |
assert(task == _first, "Sanity"); |
|
488 |
_first = task->next(); |
|
1 | 489 |
} |
490 |
||
6453 | 491 |
if (task->next() != NULL) { |
492 |
task->next()->set_prev(task->prev()); |
|
493 |
} else { |
|
494 |
// max is the last element |
|
495 |
assert(task == _last, "Sanity"); |
|
496 |
_last = task->prev(); |
|
497 |
} |
|
498 |
--_size; |
|
1 | 499 |
} |
500 |
||
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
501 |
void CompileQueue::remove_and_mark_stale(CompileTask* task) { |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
502 |
assert(MethodCompileQueue_lock->owned_by_self(), "must own lock"); |
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
503 |
remove(task); |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
504 |
|
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
505 |
// Enqueue the task for reclamation (should be done outside MCQ lock) |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
506 |
task->set_next(_first_stale); |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
507 |
task->set_prev(NULL); |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
508 |
_first_stale = task; |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
509 |
} |
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
510 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
511 |
// methods in the compile queue need to be marked as used on the stack |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
512 |
// so that they don't get reclaimed by Redefine Classes |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
513 |
void CompileQueue::mark_on_stack() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
514 |
CompileTask* task = _first; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
515 |
while (task != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
516 |
task->mark_on_stack(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
517 |
task = task->next(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
518 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
519 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
520 |
|
26587 | 521 |
|
522 |
CompileQueue* CompileBroker::compile_queue(int comp_level) { |
|
523 |
if (is_c2_compile(comp_level)) return _c2_compile_queue; |
|
524 |
if (is_c1_compile(comp_level)) return _c1_compile_queue; |
|
525 |
return NULL; |
|
526 |
} |
|
527 |
||
35825
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
528 |
void CompileBroker::print_compile_queues(outputStream* st) { |
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
529 |
st->print_cr("Current compiles: "); |
26587 | 530 |
|
35825
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
531 |
char buf[2000]; |
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
532 |
int buflen = sizeof(buf); |
54015
cd701366fcf8
8163511: Allocation of compile task fails with assert: "Leaking compilation tasks?"
thartmann
parents:
53582
diff
changeset
|
533 |
Threads::print_threads_compiling(st, buf, buflen, /* short_form = */ true); |
35825
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
534 |
|
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
535 |
st->cr(); |
26807
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
536 |
if (_c1_compile_queue != NULL) { |
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
537 |
_c1_compile_queue->print(st); |
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
538 |
} |
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
539 |
if (_c2_compile_queue != NULL) { |
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
540 |
_c2_compile_queue->print(st); |
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
541 |
} |
26587 | 542 |
} |
543 |
||
544 |
void CompileQueue::print(outputStream* st) { |
|
51026
510ac4c08610
8205472: Deadlock in Kitchensink when trying to print compile queues causing timeout
thartmann
parents:
50912
diff
changeset
|
545 |
assert_locked_or_safepoint(MethodCompileQueue_lock); |
35825
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
546 |
st->print_cr("%s:", name()); |
26587 | 547 |
CompileTask* task = _first; |
548 |
if (task == NULL) { |
|
26807
843ea33eb963
8058461: serviceability/dcmd/CodelistTest.java and serviceability/dcmd/CompilerQueueTest.java SIGSEGV
neliasso
parents:
26800
diff
changeset
|
549 |
st->print_cr("Empty"); |
26587 | 550 |
} else { |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
551 |
while (task != NULL) { |
32582
56619bb8bcaa
8135067: Preparatory refactorings for compiler control
neliasso
parents:
32391
diff
changeset
|
552 |
task->print(st, NULL, true, true); |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
553 |
task = task->next(); |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
554 |
} |
1 | 555 |
} |
35825
7c7652ee137b
8063112: Compiler diagnostic commands should have locking instead of safepoint
neliasso
parents:
35606
diff
changeset
|
556 |
st->cr(); |
1 | 557 |
} |
26587 | 558 |
|
559 |
void CompileQueue::print_tty() { |
|
560 |
ttyLocker ttyl; |
|
561 |
print(tty); |
|
562 |
} |
|
1 | 563 |
|
33168
20f107826ae8
8134607: Remove per-compiler performance counters
redestad
parents:
33160
diff
changeset
|
564 |
CompilerCounters::CompilerCounters() { |
1 | 565 |
_current_method[0] = '\0'; |
566 |
_compile_type = CompileBroker::no_compile; |
|
567 |
} |
|
568 |
||
569 |
// ------------------------------------------------------------------ |
|
570 |
// CompileBroker::compilation_init |
|
571 |
// |
|
572 |
// Initialize the Compilation object |
|
49618
c5b066caefba
8200230: [Graal] Compilations should not be enqueued before Graal is initialized
thartmann
parents:
49611
diff
changeset
|
573 |
void CompileBroker::compilation_init_phase1(TRAPS) { |
21204
1c993523cf85
8026949: -Xint flag prints wrong warning: Initialization of C1 thread failed (no space to run compilers)
anoll
parents:
21098
diff
changeset
|
574 |
// No need to initialize compilation system if we do not use it. |
1c993523cf85
8026949: -Xint flag prints wrong warning: Initialization of C1 thread failed (no space to run compilers)
anoll
parents:
21098
diff
changeset
|
575 |
if (!UseCompiler) { |
1c993523cf85
8026949: -Xint flag prints wrong warning: Initialization of C1 thread failed (no space to run compilers)
anoll
parents:
21098
diff
changeset
|
576 |
return; |
1c993523cf85
8026949: -Xint flag prints wrong warning: Initialization of C1 thread failed (no space to run compilers)
anoll
parents:
21098
diff
changeset
|
577 |
} |
1 | 578 |
// Set the interface to the current compiler(s). |
49848 | 579 |
_c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple); |
580 |
_c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization); |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
581 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
582 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
583 |
if (EnableJVMCI) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
584 |
// This is creating a JVMCICompiler singleton. |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
585 |
JVMCICompiler* jvmci = new JVMCICompiler(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
586 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
587 |
if (UseJVMCICompiler) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
588 |
_compilers[1] = jvmci; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
589 |
if (FLAG_IS_DEFAULT(JVMCIThreads)) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
590 |
if (BootstrapJVMCI) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
591 |
// JVMCI will bootstrap so give it more threads |
49848 | 592 |
_c2_count = MIN2(32, os::active_processor_count()); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
593 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
594 |
} else { |
49848 | 595 |
_c2_count = JVMCIThreads; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
596 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
597 |
if (FLAG_IS_DEFAULT(JVMCIHostThreads)) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
598 |
} else { |
49848 | 599 |
_c1_count = JVMCIHostThreads; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
600 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
601 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
602 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
603 |
#endif // INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
604 |
|
1 | 605 |
#ifdef COMPILER1 |
49848 | 606 |
if (_c1_count > 0) { |
6453 | 607 |
_compilers[0] = new Compiler(); |
608 |
} |
|
1 | 609 |
#endif // COMPILER1 |
610 |
||
611 |
#ifdef COMPILER2 |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
612 |
if (true JVMCI_ONLY( && !UseJVMCICompiler)) { |
49848 | 613 |
if (_c2_count > 0) { |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
614 |
_compilers[1] = new C2Compiler(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
615 |
} |
6453 | 616 |
} |
1 | 617 |
#endif // COMPILER2 |
618 |
||
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
619 |
// Start the compiler thread(s) and the sweeper thread |
49848 | 620 |
init_compiler_sweeper_threads(); |
1 | 621 |
// totalTime performance counter is always created as it is required |
622 |
// by the implementation of java.lang.management.CompilationMBean. |
|
623 |
{ |
|
624 |
EXCEPTION_MARK; |
|
625 |
_perf_total_compilation = |
|
626 |
PerfDataManager::create_counter(JAVA_CI, "totalTime", |
|
627 |
PerfData::U_Ticks, CHECK); |
|
628 |
} |
|
629 |
||
630 |
if (UsePerfData) { |
|
631 |
||
632 |
EXCEPTION_MARK; |
|
633 |
||
634 |
// create the jvmstat performance counters |
|
635 |
_perf_osr_compilation = |
|
636 |
PerfDataManager::create_counter(SUN_CI, "osrTime", |
|
637 |
PerfData::U_Ticks, CHECK); |
|
638 |
||
639 |
_perf_standard_compilation = |
|
640 |
PerfDataManager::create_counter(SUN_CI, "standardTime", |
|
641 |
PerfData::U_Ticks, CHECK); |
|
642 |
||
643 |
_perf_total_bailout_count = |
|
644 |
PerfDataManager::create_counter(SUN_CI, "totalBailouts", |
|
645 |
PerfData::U_Events, CHECK); |
|
646 |
||
647 |
_perf_total_invalidated_count = |
|
648 |
PerfDataManager::create_counter(SUN_CI, "totalInvalidates", |
|
649 |
PerfData::U_Events, CHECK); |
|
650 |
||
651 |
_perf_total_compile_count = |
|
652 |
PerfDataManager::create_counter(SUN_CI, "totalCompiles", |
|
653 |
PerfData::U_Events, CHECK); |
|
654 |
_perf_total_osr_compile_count = |
|
655 |
PerfDataManager::create_counter(SUN_CI, "osrCompiles", |
|
656 |
PerfData::U_Events, CHECK); |
|
657 |
||
658 |
_perf_total_standard_compile_count = |
|
659 |
PerfDataManager::create_counter(SUN_CI, "standardCompiles", |
|
660 |
PerfData::U_Events, CHECK); |
|
661 |
||
662 |
_perf_sum_osr_bytes_compiled = |
|
663 |
PerfDataManager::create_counter(SUN_CI, "osrBytes", |
|
664 |
PerfData::U_Bytes, CHECK); |
|
665 |
||
666 |
_perf_sum_standard_bytes_compiled = |
|
667 |
PerfDataManager::create_counter(SUN_CI, "standardBytes", |
|
668 |
PerfData::U_Bytes, CHECK); |
|
669 |
||
670 |
_perf_sum_nmethod_size = |
|
671 |
PerfDataManager::create_counter(SUN_CI, "nmethodSize", |
|
672 |
PerfData::U_Bytes, CHECK); |
|
673 |
||
674 |
_perf_sum_nmethod_code_size = |
|
675 |
PerfDataManager::create_counter(SUN_CI, "nmethodCodeSize", |
|
676 |
PerfData::U_Bytes, CHECK); |
|
677 |
||
678 |
_perf_last_method = |
|
679 |
PerfDataManager::create_string_variable(SUN_CI, "lastMethod", |
|
680 |
CompilerCounters::cmname_buffer_length, |
|
681 |
"", CHECK); |
|
682 |
||
683 |
_perf_last_failed_method = |
|
684 |
PerfDataManager::create_string_variable(SUN_CI, "lastFailedMethod", |
|
685 |
CompilerCounters::cmname_buffer_length, |
|
686 |
"", CHECK); |
|
687 |
||
688 |
_perf_last_invalidated_method = |
|
689 |
PerfDataManager::create_string_variable(SUN_CI, "lastInvalidatedMethod", |
|
690 |
CompilerCounters::cmname_buffer_length, |
|
691 |
"", CHECK); |
|
692 |
||
693 |
_perf_last_compile_type = |
|
694 |
PerfDataManager::create_variable(SUN_CI, "lastType", |
|
695 |
PerfData::U_None, |
|
696 |
(jlong)CompileBroker::no_compile, |
|
697 |
CHECK); |
|
698 |
||
699 |
_perf_last_compile_size = |
|
700 |
PerfDataManager::create_variable(SUN_CI, "lastSize", |
|
701 |
PerfData::U_Bytes, |
|
702 |
(jlong)CompileBroker::no_compile, |
|
703 |
CHECK); |
|
704 |
||
705 |
||
706 |
_perf_last_failed_type = |
|
707 |
PerfDataManager::create_variable(SUN_CI, "lastFailedType", |
|
708 |
PerfData::U_None, |
|
709 |
(jlong)CompileBroker::no_compile, |
|
710 |
CHECK); |
|
711 |
||
712 |
_perf_last_invalidated_type = |
|
713 |
PerfDataManager::create_variable(SUN_CI, "lastInvalidatedType", |
|
714 |
PerfData::U_None, |
|
715 |
(jlong)CompileBroker::no_compile, |
|
716 |
CHECK); |
|
717 |
} |
|
49618
c5b066caefba
8200230: [Graal] Compilations should not be enqueued before Graal is initialized
thartmann
parents:
49611
diff
changeset
|
718 |
} |
1 | 719 |
|
49618
c5b066caefba
8200230: [Graal] Compilations should not be enqueued before Graal is initialized
thartmann
parents:
49611
diff
changeset
|
720 |
// Completes compiler initialization. Compilation requests submitted |
c5b066caefba
8200230: [Graal] Compilations should not be enqueued before Graal is initialized
thartmann
parents:
49611
diff
changeset
|
721 |
// prior to this will be silently ignored. |
c5b066caefba
8200230: [Graal] Compilations should not be enqueued before Graal is initialized
thartmann
parents:
49611
diff
changeset
|
722 |
void CompileBroker::compilation_init_phase2() { |
1 | 723 |
_initialized = true; |
724 |
} |
|
725 |
||
49848 | 726 |
Handle CompileBroker::create_thread_oop(const char* name, TRAPS) { |
727 |
Handle string = java_lang_String::create_from_str(name, CHECK_NH); |
|
728 |
Handle thread_group(THREAD, Universe::system_thread_group()); |
|
50217
843fc56f4686
8203381: Replace InstanceKlass::allocate_instance_handle with JavaCalls::construct_new_instance
iklam
parents:
50113
diff
changeset
|
729 |
return JavaCalls::construct_new_instance( |
843fc56f4686
8203381: Replace InstanceKlass::allocate_instance_handle with JavaCalls::construct_new_instance
iklam
parents:
50113
diff
changeset
|
730 |
SystemDictionary::Thread_klass(), |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
731 |
vmSymbols::threadgroup_string_void_signature(), |
1 | 732 |
thread_group, |
733 |
string, |
|
49848 | 734 |
CHECK_NH); |
735 |
} |
|
1 | 736 |
|
49848 | 737 |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
738 |
JavaThread* CompileBroker::make_thread(jobject thread_handle, CompileQueue* queue, AbstractCompiler* comp, TRAPS) { |
49848 | 739 |
JavaThread* thread = NULL; |
1 | 740 |
{ |
741 |
MutexLocker mu(Threads_lock, THREAD); |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
742 |
if (comp != NULL) { |
49848 | 743 |
if (!InjectCompilerCreationFailure || comp->num_compiler_threads() == 0) { |
744 |
CompilerCounters* counters = new CompilerCounters(); |
|
745 |
thread = new CompilerThread(queue, counters); |
|
746 |
} |
|
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
747 |
} else { |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
748 |
thread = new CodeCacheSweeperThread(); |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
749 |
} |
1 | 750 |
// At this point the new CompilerThread data-races with this startup |
751 |
// thread (which I believe is the primoridal thread and NOT the VM |
|
752 |
// thread). This means Java bytecodes being executed at startup can |
|
753 |
// queue compile jobs which will run at whatever default priority the |
|
754 |
// newly created CompilerThread runs at. |
|
755 |
||
756 |
||
757 |
// At this point it may be possible that no osthread was created for the |
|
758 |
// JavaThread due to lack of memory. We would have to throw an exception |
|
759 |
// in that case. However, since this must work and we do not allow |
|
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
760 |
// exceptions anyway, check and abort if this fails. But first release the |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
761 |
// lock. |
1 | 762 |
|
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
763 |
if (thread != NULL && thread->osthread() != NULL) { |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
764 |
|
49848 | 765 |
java_lang_Thread::set_thread(JNIHandles::resolve_non_null(thread_handle), thread); |
1 | 766 |
|
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
767 |
// Note that this only sets the JavaThread _priority field, which by |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
768 |
// definition is limited to Java priorities and not OS priorities. |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
769 |
// The os-priority is set in the CompilerThread startup code itself |
1 | 770 |
|
49848 | 771 |
java_lang_Thread::set_priority(JNIHandles::resolve_non_null(thread_handle), NearMaxPriority); |
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11198
diff
changeset
|
772 |
|
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
773 |
// Note that we cannot call os::set_priority because it expects Java |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
774 |
// priorities and we are *explicitly* using OS priorities so that it's |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
775 |
// possible to set the compiler thread priority higher than any Java |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
776 |
// thread. |
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11198
diff
changeset
|
777 |
|
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
778 |
int native_prio = CompilerThreadPriority; |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
779 |
if (native_prio == -1) { |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
780 |
if (UseCriticalCompilerThreadPriority) { |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
781 |
native_prio = os::java_to_os_priority[CriticalPriority]; |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
782 |
} else { |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
783 |
native_prio = os::java_to_os_priority[NearMaxPriority]; |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
784 |
} |
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11198
diff
changeset
|
785 |
} |
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
786 |
os::set_native_priority(thread, native_prio); |
1 | 787 |
|
49848 | 788 |
java_lang_Thread::set_daemon(JNIHandles::resolve_non_null(thread_handle)); |
1 | 789 |
|
49848 | 790 |
thread->set_threadObj(JNIHandles::resolve_non_null(thread_handle)); |
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
791 |
if (comp != NULL) { |
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
792 |
thread->as_CompilerThread()->set_compiler(comp); |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
793 |
} |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
794 |
Threads::add(thread); |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
795 |
Thread::start(thread); |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
796 |
} |
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
797 |
} |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
798 |
|
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
799 |
// First release lock before aborting VM. |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
800 |
if (thread == NULL || thread->osthread() == NULL) { |
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
801 |
if (UseDynamicNumberOfCompilerThreads && comp != NULL && comp->num_compiler_threads() > 0) { |
49848 | 802 |
if (thread != NULL) { |
803 |
thread->smr_delete(); |
|
804 |
} |
|
805 |
return NULL; |
|
806 |
} |
|
46986
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
807 |
vm_exit_during_initialization("java.lang.OutOfMemoryError", |
26697fda7a45
8186437: Lock held when compiler thread creation fails.
goetz
parents:
46701
diff
changeset
|
808 |
os::native_thread_creation_failed_msg()); |
1 | 809 |
} |
11601
f359304c1856
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
11198
diff
changeset
|
810 |
|
1 | 811 |
// Let go of Threads_lock before yielding |
25477
7dad9f95fd31
8047714: Fix for JDK-6546236 made Solaris os::yield() a no-op
fparain
parents:
25365
diff
changeset
|
812 |
os::naked_yield(); // make sure that the compiler thread is started early (especially helpful on SOLARIS) |
1 | 813 |
|
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
814 |
return thread; |
1 | 815 |
} |
816 |
||
817 |
||
49848 | 818 |
void CompileBroker::init_compiler_sweeper_threads() { |
1 | 819 |
EXCEPTION_MARK; |
47687 | 820 |
#if !defined(ZERO) |
49848 | 821 |
assert(_c2_count > 0 || _c1_count > 0, "No compilers?"); |
47687 | 822 |
#endif // !ZERO |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
823 |
// Initialize the compilation queue |
49848 | 824 |
if (_c2_count > 0) { |
36806
b9a6883c30ee
8152134: [JVMCI] printing compile queues always prints C2 regardless of UseJVMCICompiler
twisti
parents:
36597
diff
changeset
|
825 |
const char* name = JVMCI_ONLY(UseJVMCICompiler ? "JVMCI compile queue" :) "C2 compile queue"; |
b9a6883c30ee
8152134: [JVMCI] printing compile queues always prints C2 regardless of UseJVMCICompiler
twisti
parents:
36597
diff
changeset
|
826 |
_c2_compile_queue = new CompileQueue(name); |
49848 | 827 |
_compiler2_objects = NEW_C_HEAP_ARRAY(jobject, _c2_count, mtCompiler); |
828 |
_compiler2_logs = NEW_C_HEAP_ARRAY(CompileLog*, _c2_count, mtCompiler); |
|
6453 | 829 |
} |
49848 | 830 |
if (_c1_count > 0) { |
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
831 |
_c1_compile_queue = new CompileQueue("C1 compile queue"); |
49848 | 832 |
_compiler1_objects = NEW_C_HEAP_ARRAY(jobject, _c1_count, mtCompiler); |
833 |
_compiler1_logs = NEW_C_HEAP_ARRAY(CompileLog*, _c1_count, mtCompiler); |
|
6453 | 834 |
} |
1 | 835 |
|
49848 | 836 |
char name_buffer[256]; |
6453 | 837 |
|
49848 | 838 |
for (int i = 0; i < _c2_count; i++) { |
1 | 839 |
// Create a name for our thread. |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
840 |
sprintf(name_buffer, "%s CompilerThread%d", _compilers[1]->name(), i); |
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
841 |
Handle thread_oop = create_thread_oop(name_buffer, CHECK); |
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
842 |
jobject thread_handle = JNIHandles::make_global(thread_oop); |
49848 | 843 |
_compiler2_objects[i] = thread_handle; |
844 |
_compiler2_logs[i] = NULL; |
|
845 |
||
846 |
if (!UseDynamicNumberOfCompilerThreads || i == 0) { |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
847 |
JavaThread *ct = make_thread(thread_handle, _c2_compile_queue, _compilers[1], CHECK); |
49848 | 848 |
assert(ct != NULL, "should have been handled for initial thread"); |
849 |
_compilers[1]->set_num_compiler_threads(i + 1); |
|
850 |
if (TraceCompilerThreads) { |
|
851 |
ResourceMark rm; |
|
852 |
MutexLocker mu(Threads_lock); |
|
853 |
tty->print_cr("Added initial compiler thread %s", ct->get_thread_name()); |
|
854 |
} |
|
855 |
} |
|
1 | 856 |
} |
6453 | 857 |
|
49848 | 858 |
for (int i = 0; i < _c1_count; i++) { |
6453 | 859 |
// Create a name for our thread. |
860 |
sprintf(name_buffer, "C1 CompilerThread%d", i); |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
861 |
Handle thread_oop = create_thread_oop(name_buffer, CHECK); |
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
862 |
jobject thread_handle = JNIHandles::make_global(thread_oop); |
49848 | 863 |
_compiler1_objects[i] = thread_handle; |
864 |
_compiler1_logs[i] = NULL; |
|
865 |
||
866 |
if (!UseDynamicNumberOfCompilerThreads || i == 0) { |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
867 |
JavaThread *ct = make_thread(thread_handle, _c1_compile_queue, _compilers[0], CHECK); |
49848 | 868 |
assert(ct != NULL, "should have been handled for initial thread"); |
869 |
_compilers[0]->set_num_compiler_threads(i + 1); |
|
870 |
if (TraceCompilerThreads) { |
|
871 |
ResourceMark rm; |
|
872 |
MutexLocker mu(Threads_lock); |
|
873 |
tty->print_cr("Added initial compiler thread %s", ct->get_thread_name()); |
|
874 |
} |
|
875 |
} |
|
6453 | 876 |
} |
877 |
||
1 | 878 |
if (UsePerfData) { |
49848 | 879 |
PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes, _c1_count + _c2_count, CHECK); |
1 | 880 |
} |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
881 |
|
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
882 |
if (MethodFlushing) { |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
883 |
// Initialize the sweeper thread |
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
884 |
Handle thread_oop = create_thread_oop("Sweeper thread", CHECK); |
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
885 |
jobject thread_handle = JNIHandles::make_local(THREAD, thread_oop()); |
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
886 |
make_thread(thread_handle, NULL, NULL, CHECK); |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
887 |
} |
1 | 888 |
} |
889 |
||
49848 | 890 |
void CompileBroker::possibly_add_compiler_threads() { |
891 |
EXCEPTION_MARK; |
|
892 |
||
893 |
julong available_memory = os::available_memory(); |
|
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
894 |
// If SegmentedCodeCache is off, both values refer to the single heap (with type CodeBlobType::All). |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
895 |
size_t available_cc_np = CodeCache::unallocated_capacity(CodeBlobType::MethodNonProfiled), |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
896 |
available_cc_p = CodeCache::unallocated_capacity(CodeBlobType::MethodProfiled); |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
897 |
|
49848 | 898 |
// Only do attempt to start additional threads if the lock is free. |
899 |
if (!CompileThread_lock->try_lock()) return; |
|
900 |
||
901 |
if (_c2_compile_queue != NULL) { |
|
902 |
int old_c2_count = _compilers[1]->num_compiler_threads(); |
|
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
903 |
int new_c2_count = MIN4(_c2_count, |
49848 | 904 |
_c2_compile_queue->size() / 2, |
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
905 |
(int)(available_memory / (200*M)), |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
906 |
(int)(available_cc_np / (128*K))); |
49848 | 907 |
|
908 |
for (int i = old_c2_count; i < new_c2_count; i++) { |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
909 |
JavaThread *ct = make_thread(compiler2_object(i), _c2_compile_queue, _compilers[1], CHECK); |
49848 | 910 |
if (ct == NULL) break; |
911 |
_compilers[1]->set_num_compiler_threads(i + 1); |
|
912 |
if (TraceCompilerThreads) { |
|
913 |
ResourceMark rm; |
|
914 |
MutexLocker mu(Threads_lock); |
|
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
915 |
tty->print_cr("Added compiler thread %s (available memory: %dMB, available non-profiled code cache: %dMB)", |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
916 |
ct->get_thread_name(), (int)(available_memory/M), (int)(available_cc_np/M)); |
49848 | 917 |
} |
918 |
} |
|
919 |
} |
|
920 |
||
921 |
if (_c1_compile_queue != NULL) { |
|
922 |
int old_c1_count = _compilers[0]->num_compiler_threads(); |
|
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
923 |
int new_c1_count = MIN4(_c1_count, |
49848 | 924 |
_c1_compile_queue->size() / 4, |
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
925 |
(int)(available_memory / (100*M)), |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
926 |
(int)(available_cc_p / (128*K))); |
49848 | 927 |
|
928 |
for (int i = old_c1_count; i < new_c1_count; i++) { |
|
52369
52f892f43a05
8213014: Crash in CompileBroker::make_thread due to OOM
thartmann
parents:
52350
diff
changeset
|
929 |
JavaThread *ct = make_thread(compiler1_object(i), _c1_compile_queue, _compilers[0], CHECK); |
49848 | 930 |
if (ct == NULL) break; |
931 |
_compilers[0]->set_num_compiler_threads(i + 1); |
|
932 |
if (TraceCompilerThreads) { |
|
933 |
ResourceMark rm; |
|
934 |
MutexLocker mu(Threads_lock); |
|
52350
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
935 |
tty->print_cr("Added compiler thread %s (available memory: %dMB, available profiled code cache: %dMB)", |
9e3fd0cc3936
8213086: Compiler thread creation should be bounded by available space in memory and Code Cache
mdoerr
parents:
52336
diff
changeset
|
936 |
ct->get_thread_name(), (int)(available_memory/M), (int)(available_cc_p/M)); |
49848 | 937 |
} |
938 |
} |
|
939 |
} |
|
940 |
||
941 |
CompileThread_lock->unlock(); |
|
942 |
} |
|
943 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
944 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
945 |
/** |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
946 |
* Set the methods on the stack as on_stack so that redefine classes doesn't |
24350
8d8c1012dacd
8042570: Excessive number of tests timing out on nightly testing due to fix for 8040798
anoll
parents:
24346
diff
changeset
|
947 |
* reclaim them. This method is executed at a safepoint. |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
948 |
*/ |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
949 |
void CompileBroker::mark_on_stack() { |
24350
8d8c1012dacd
8042570: Excessive number of tests timing out on nightly testing due to fix for 8040798
anoll
parents:
24346
diff
changeset
|
950 |
assert(SafepointSynchronize::is_at_safepoint(), "sanity check"); |
8d8c1012dacd
8042570: Excessive number of tests timing out on nightly testing due to fix for 8040798
anoll
parents:
24346
diff
changeset
|
951 |
// Since we are at a safepoint, we do not need a lock to access |
8d8c1012dacd
8042570: Excessive number of tests timing out on nightly testing due to fix for 8040798
anoll
parents:
24346
diff
changeset
|
952 |
// the compile queues. |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
953 |
if (_c2_compile_queue != NULL) { |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
954 |
_c2_compile_queue->mark_on_stack(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
955 |
} |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
956 |
if (_c1_compile_queue != NULL) { |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
957 |
_c1_compile_queue->mark_on_stack(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
958 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
959 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
960 |
|
1 | 961 |
// ------------------------------------------------------------------ |
962 |
// CompileBroker::compile_method |
|
963 |
// |
|
964 |
// Request compilation of a method. |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
965 |
void CompileBroker::compile_method_base(const methodHandle& method, |
1 | 966 |
int osr_bci, |
967 |
int comp_level, |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
968 |
const methodHandle& hot_method, |
1 | 969 |
int hot_count, |
38218 | 970 |
CompileTask::CompileReason compile_reason, |
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
971 |
bool blocking, |
11572
84afef481892
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
11198
diff
changeset
|
972 |
Thread* thread) { |
1 | 973 |
guarantee(!method->is_abstract(), "cannot compile abstract methods"); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33593
diff
changeset
|
974 |
assert(method->method_holder()->is_instance_klass(), |
1 | 975 |
"sanity check"); |
14391
df0a1573d5bd
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
13964
diff
changeset
|
976 |
assert(!method->method_holder()->is_not_initialized(), |
1 | 977 |
"method holder must be initialized"); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13195
diff
changeset
|
978 |
assert(!method->is_method_handle_intrinsic(), "do not enqueue these guys"); |
1 | 979 |
|
980 |
if (CIPrintRequests) { |
|
981 |
tty->print("request: "); |
|
982 |
method->print_short_name(tty); |
|
983 |
if (osr_bci != InvocationEntryBci) { |
|
984 |
tty->print(" osr_bci: %d", osr_bci); |
|
985 |
} |
|
38218 | 986 |
tty->print(" level: %d comment: %s count: %d", comp_level, CompileTask::reason_name(compile_reason), hot_count); |
1 | 987 |
if (!hot_method.is_null()) { |
988 |
tty->print(" hot: "); |
|
989 |
if (hot_method() != method()) { |
|
990 |
hot_method->print_short_name(tty); |
|
991 |
} else { |
|
992 |
tty->print("yes"); |
|
993 |
} |
|
994 |
} |
|
995 |
tty->cr(); |
|
996 |
} |
|
997 |
||
998 |
// A request has been made for compilation. Before we do any |
|
999 |
// real work, check to see if the method has been compiled |
|
1000 |
// in the meantime with a definitive result. |
|
1001 |
if (compilation_is_complete(method, osr_bci, comp_level)) { |
|
1002 |
return; |
|
1003 |
} |
|
1004 |
||
8870 | 1005 |
#ifndef PRODUCT |
1006 |
if (osr_bci != -1 && !FLAG_IS_DEFAULT(OSROnlyBCI)) { |
|
1007 |
if ((OSROnlyBCI > 0) ? (OSROnlyBCI != osr_bci) : (-OSROnlyBCI == osr_bci)) { |
|
1008 |
// Positive OSROnlyBCI means only compile that bci. Negative means don't compile that BCI. |
|
1009 |
return; |
|
1010 |
} |
|
1011 |
} |
|
1012 |
#endif |
|
6453 | 1013 |
|
1 | 1014 |
// If this method is already in the compile queue, then |
1015 |
// we do not block the current thread. |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1016 |
if (compilation_is_in_queue(method)) { |
1 | 1017 |
// We may want to decay our counter a bit here to prevent |
1018 |
// multiple denied requests for compilation. This is an |
|
1019 |
// open compilation policy issue. Note: The other possibility, |
|
1020 |
// in the case that this is a blocking compile request, is to have |
|
1021 |
// all subsequent blocking requesters wait for completion of |
|
1022 |
// ongoing compiles. Note that in this case we'll need a protocol |
|
1023 |
// for freeing the associated compile tasks. [Or we could have |
|
1024 |
// a single static monitor on which all these waiters sleep.] |
|
1025 |
return; |
|
1026 |
} |
|
1027 |
||
26799
0c349e16bbe8
8058564: Tiered compilation performance drop in PIT
iveresov
parents:
26796
diff
changeset
|
1028 |
if (TieredCompilation) { |
0c349e16bbe8
8058564: Tiered compilation performance drop in PIT
iveresov
parents:
26796
diff
changeset
|
1029 |
// Tiered policy requires MethodCounters to exist before adding a method to |
0c349e16bbe8
8058564: Tiered compilation performance drop in PIT
iveresov
parents:
26796
diff
changeset
|
1030 |
// the queue. Create if we don't have them yet. |
0c349e16bbe8
8058564: Tiered compilation performance drop in PIT
iveresov
parents:
26796
diff
changeset
|
1031 |
method->get_method_counters(thread); |
0c349e16bbe8
8058564: Tiered compilation performance drop in PIT
iveresov
parents:
26796
diff
changeset
|
1032 |
} |
0c349e16bbe8
8058564: Tiered compilation performance drop in PIT
iveresov
parents:
26796
diff
changeset
|
1033 |
|
1 | 1034 |
// Outputs from the following MutexLocker block: |
1035 |
CompileTask* task = NULL; |
|
6453 | 1036 |
CompileQueue* queue = compile_queue(comp_level); |
1 | 1037 |
|
1038 |
// Acquire our lock. |
|
1039 |
{ |
|
27696
c43940b3cf78
8061256: com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java timed out
neliasso
parents:
27642
diff
changeset
|
1040 |
MutexLocker locker(MethodCompileQueue_lock, thread); |
1 | 1041 |
|
1042 |
// Make sure the method has not slipped into the queues since |
|
1043 |
// last we checked; note that those checks were "fast bail-outs". |
|
1044 |
// Here we need to be more careful, see 14012000 below. |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1045 |
if (compilation_is_in_queue(method)) { |
1 | 1046 |
return; |
1047 |
} |
|
1048 |
||
1049 |
// We need to check again to see if the compilation has |
|
1050 |
// completed. A previous compilation may have registered |
|
1051 |
// some result. |
|
1052 |
if (compilation_is_complete(method, osr_bci, comp_level)) { |
|
1053 |
return; |
|
1054 |
} |
|
1055 |
||
1056 |
// We now know that this compilation is not pending, complete, |
|
1057 |
// or prohibited. Assign a compile_id to this compilation |
|
1058 |
// and check to see if it is in our [Start..Stop) range. |
|
22247 | 1059 |
int compile_id = assign_compile_id(method, osr_bci); |
1 | 1060 |
if (compile_id == 0) { |
1061 |
// The compilation falls outside the allowed range. |
|
1062 |
return; |
|
1063 |
} |
|
1064 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1065 |
#if INCLUDE_JVMCI |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1066 |
if (UseJVMCICompiler && blocking && !UseJVMCINativeLibrary) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1067 |
// Don't allow blocking compiles for requests triggered by JVMCI. |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1068 |
if (thread->is_Compiler_thread()) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1069 |
blocking = false; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1070 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1071 |
|
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1072 |
// Don't allow blocking compiles if inside a class initializer or while performing class loading |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1073 |
vframeStream vfst((JavaThread*) thread); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1074 |
for (; !vfst.at_end(); vfst.next()) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1075 |
if (vfst.method()->is_static_initializer() || |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1076 |
(vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass()) && |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1077 |
vfst.method()->name() == vmSymbols::loadClass_name())) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1078 |
blocking = false; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1079 |
break; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1080 |
} |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1081 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1082 |
|
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1083 |
// Don't allow blocking compilation requests to JVMCI |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1084 |
// if JVMCI itself is not yet initialized |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1085 |
if (!JVMCI::is_compiler_initialized() && compiler(comp_level)->is_jvmci()) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1086 |
blocking = false; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1087 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1088 |
|
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1089 |
// Don't allow blocking compilation requests if we are in JVMCIRuntime::shutdown |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1090 |
// to avoid deadlock between compiler thread(s) and threads run at shutdown |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1091 |
// such as the DestroyJavaVM thread. |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1092 |
if (JVMCI::shutdown_called()) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1093 |
blocking = false; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1094 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1095 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1096 |
#endif // INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1097 |
|
1 | 1098 |
// We will enter the compilation in the queue. |
1099 |
// 14012000: Note that this sets the queued_for_compile bits in |
|
1100 |
// the target method. We can now reason that a method cannot be |
|
1101 |
// queued for compilation more than once, as follows: |
|
1102 |
// Before a thread queues a task for compilation, it first acquires |
|
1103 |
// the compile queue lock, then checks if the method's queued bits |
|
1104 |
// are set or it has already been compiled. Thus there can not be two |
|
1105 |
// instances of a compilation task for the same method on the |
|
1106 |
// compilation queue. Consider now the case where the compilation |
|
1107 |
// thread has already removed a task for that method from the queue |
|
1108 |
// and is in the midst of compiling it. In this case, the |
|
1109 |
// queued_for_compile bits must be set in the method (and these |
|
1110 |
// will be visible to the current thread, since the bits were set |
|
1111 |
// under protection of the compile queue lock, which we hold now. |
|
1112 |
// When the compilation completes, the compiler thread first sets |
|
1113 |
// the compilation result and then clears the queued_for_compile |
|
1114 |
// bits. Neither of these actions are protected by a barrier (or done |
|
1115 |
// under the protection of a lock), so the only guarantee we have |
|
1116 |
// (on machines with TSO (Total Store Order)) is that these values |
|
1117 |
// will update in that order. As a result, the only combinations of |
|
1118 |
// these bits that the current thread will see are, in temporal order: |
|
1119 |
// <RESULT, QUEUE> : |
|
1120 |
// <0, 1> : in compile queue, but not yet compiled |
|
1121 |
// <1, 1> : compiled but queue bit not cleared |
|
1122 |
// <1, 0> : compiled and queue bit cleared |
|
1123 |
// Because we first check the queue bits then check the result bits, |
|
1124 |
// we are assured that we cannot introduce a duplicate task. |
|
1125 |
// Note that if we did the tests in the reverse order (i.e. check |
|
1126 |
// result then check queued bit), we could get the result bit before |
|
1127 |
// the compilation completed, and the queue bit after the compilation |
|
1128 |
// completed, and end up introducing a "duplicate" (redundant) task. |
|
1129 |
// In that case, the compiler thread should first check if a method |
|
1130 |
// has already been compiled before trying to compile it. |
|
1131 |
// NOTE: in the event that there are multiple compiler threads and |
|
1132 |
// there is de-optimization/recompilation, things will get hairy, |
|
1133 |
// and in that case it's best to protect both the testing (here) of |
|
1134 |
// these bits, and their updating (here and elsewhere) under a |
|
1135 |
// common lock. |
|
6453 | 1136 |
task = create_compile_task(queue, |
1 | 1137 |
compile_id, method, |
1138 |
osr_bci, comp_level, |
|
38218 | 1139 |
hot_method, hot_count, compile_reason, |
1 | 1140 |
blocking); |
1141 |
} |
|
1142 |
||
1143 |
if (blocking) { |
|
1144 |
wait_for_completion(task); |
|
1145 |
} |
|
1146 |
} |
|
1147 |
||
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1148 |
nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci, |
6453 | 1149 |
int comp_level, |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1150 |
const methodHandle& hot_method, int hot_count, |
38218 | 1151 |
CompileTask::CompileReason compile_reason, |
1152 |
Thread* THREAD) { |
|
38217
7ecc47b7df3d
8154151: VM crashes with assert "Ensure we don't compile before compilebroker init"
neliasso
parents:
38133
diff
changeset
|
1153 |
// Do nothing if compilebroker is not initalized or compiles are submitted on level none |
7ecc47b7df3d
8154151: VM crashes with assert "Ensure we don't compile before compilebroker init"
neliasso
parents:
38133
diff
changeset
|
1154 |
if (!_initialized || comp_level == CompLevel_none) { |
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1155 |
return NULL; |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1156 |
} |
38217
7ecc47b7df3d
8154151: VM crashes with assert "Ensure we don't compile before compilebroker init"
neliasso
parents:
38133
diff
changeset
|
1157 |
|
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1158 |
AbstractCompiler *comp = CompileBroker::compiler(comp_level); |
38217
7ecc47b7df3d
8154151: VM crashes with assert "Ensure we don't compile before compilebroker init"
neliasso
parents:
38133
diff
changeset
|
1159 |
assert(comp != NULL, "Ensure we have a compiler"); |
7ecc47b7df3d
8154151: VM crashes with assert "Ensure we don't compile before compilebroker init"
neliasso
parents:
38133
diff
changeset
|
1160 |
|
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1161 |
DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, comp); |
38218 | 1162 |
nmethod* nm = CompileBroker::compile_method(method, osr_bci, comp_level, hot_method, hot_count, compile_reason, directive, THREAD); |
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1163 |
DirectivesStack::release(directive); |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1164 |
return nm; |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1165 |
} |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1166 |
|
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1167 |
nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci, |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1168 |
int comp_level, |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1169 |
const methodHandle& hot_method, int hot_count, |
38218 | 1170 |
CompileTask::CompileReason compile_reason, |
1171 |
DirectiveSet* directive, |
|
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1172 |
Thread* THREAD) { |
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1173 |
|
1 | 1174 |
// make sure arguments make sense |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33593
diff
changeset
|
1175 |
assert(method->method_holder()->is_instance_klass(), "not an instance method"); |
1 | 1176 |
assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range"); |
1177 |
assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods"); |
|
14391
df0a1573d5bd
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
13964
diff
changeset
|
1178 |
assert(!method->method_holder()->is_not_initialized(), "method holder must be initialized"); |
38036
f51b942d970c
8154073: Several compiler tests fail when are executed with C1 only
thartmann
parents:
37296
diff
changeset
|
1179 |
assert(!TieredCompilation || comp_level <= TieredStopAtLevel, "Invalid compilation level"); |
16689
efce070b8d42
8007288: Additional WB API for compiler's testing
iignatyev
parents:
16611
diff
changeset
|
1180 |
// allow any levels for WhiteBox |
efce070b8d42
8007288: Additional WB API for compiler's testing
iignatyev
parents:
16611
diff
changeset
|
1181 |
assert(WhiteBoxAPI || TieredCompilation || comp_level == CompLevel_highest_tier, "only CompLevel_highest_tier must be used in non-tiered"); |
1 | 1182 |
// return quickly if possible |
1183 |
||
1184 |
// lock, make sure that the compilation |
|
1185 |
// isn't prohibited in a straightforward way. |
|
46375
1b360c12efc7
8171813: Reported null pointer dereference defect groups
rraghavan
parents:
46329
diff
changeset
|
1186 |
AbstractCompiler* comp = CompileBroker::compiler(comp_level); |
1b360c12efc7
8171813: Reported null pointer dereference defect groups
rraghavan
parents:
46329
diff
changeset
|
1187 |
if (comp == NULL || !comp->can_compile_method(method) || |
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1188 |
compilation_is_prohibited(method, osr_bci, comp_level, directive->ExcludeOption)) { |
1 | 1189 |
return NULL; |
1190 |
} |
|
1191 |
||
40074
135bb8aa1e18
8161274: [JVMCI] compiler/jvmci/events/JvmciNotifyInstallEventTest.java fails with NoClassDefFound
dnsimon
parents:
40034
diff
changeset
|
1192 |
#if INCLUDE_JVMCI |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
1193 |
if (comp->is_jvmci() && !JVMCI::can_initialize_JVMCI()) { |
40074
135bb8aa1e18
8161274: [JVMCI] compiler/jvmci/events/JvmciNotifyInstallEventTest.java fails with NoClassDefFound
dnsimon
parents:
40034
diff
changeset
|
1194 |
return NULL; |
135bb8aa1e18
8161274: [JVMCI] compiler/jvmci/events/JvmciNotifyInstallEventTest.java fails with NoClassDefFound
dnsimon
parents:
40034
diff
changeset
|
1195 |
} |
135bb8aa1e18
8161274: [JVMCI] compiler/jvmci/events/JvmciNotifyInstallEventTest.java fails with NoClassDefFound
dnsimon
parents:
40034
diff
changeset
|
1196 |
#endif |
135bb8aa1e18
8161274: [JVMCI] compiler/jvmci/events/JvmciNotifyInstallEventTest.java fails with NoClassDefFound
dnsimon
parents:
40034
diff
changeset
|
1197 |
|
1 | 1198 |
if (osr_bci == InvocationEntryBci) { |
1199 |
// standard compilation |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1200 |
CompiledMethod* method_code = method->code(); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1201 |
if (method_code != NULL && method_code->is_nmethod()) { |
6453 | 1202 |
if (compilation_is_complete(method, osr_bci, comp_level)) { |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1203 |
return (nmethod*) method_code; |
6453 | 1204 |
} |
1 | 1205 |
} |
20290
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
1206 |
if (method->is_not_compilable(comp_level)) { |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
1207 |
return NULL; |
4750 | 1208 |
} |
1 | 1209 |
} else { |
1210 |
// osr compilation |
|
1211 |
#ifndef TIERED |
|
1212 |
// seems like an assert of dubious value |
|
6453 | 1213 |
assert(comp_level == CompLevel_highest_tier, |
32582
56619bb8bcaa
8135067: Preparatory refactorings for compiler control
neliasso
parents:
32391
diff
changeset
|
1214 |
"all OSR compiles are assumed to be at a single compilation level"); |
1 | 1215 |
#endif // TIERED |
6453 | 1216 |
// We accept a higher level osr method |
1217 |
nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false); |
|
1 | 1218 |
if (nm != NULL) return nm; |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
1219 |
if (method->is_not_osr_compilable(comp_level)) return NULL; |
1 | 1220 |
} |
1221 |
||
1222 |
assert(!HAS_PENDING_EXCEPTION, "No exception should be present"); |
|
1223 |
// some prerequisites that are compiler specific |
|
47687 | 1224 |
if (comp->is_c2()) { |
11572
84afef481892
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
11198
diff
changeset
|
1225 |
method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL); |
1 | 1226 |
// Resolve all classes seen in the signature of the method |
1227 |
// we are compiling. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1228 |
Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL); |
1 | 1229 |
} |
1230 |
||
1231 |
// If the method is native, do the lookup in the thread requesting |
|
1232 |
// the compilation. Native lookups can load code, which is not |
|
1233 |
// permitted during compilation. |
|
1234 |
// |
|
1235 |
// Note: A native method implies non-osr compilation which is |
|
1236 |
// checked with an assertion at the entry of this method. |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13195
diff
changeset
|
1237 |
if (method->is_native() && !method->is_method_handle_intrinsic()) { |
1 | 1238 |
bool in_base_library; |
1239 |
address adr = NativeLookup::lookup(method, in_base_library, THREAD); |
|
1240 |
if (HAS_PENDING_EXCEPTION) { |
|
1241 |
// In case of an exception looking up the method, we just forget |
|
1242 |
// about it. The interpreter will kick-in and throw the exception. |
|
1243 |
method->set_not_compilable(); // implies is_not_osr_compilable() |
|
1244 |
CLEAR_PENDING_EXCEPTION; |
|
1245 |
return NULL; |
|
1246 |
} |
|
1247 |
assert(method->has_native_function(), "must have native code by now"); |
|
1248 |
} |
|
1249 |
||
1250 |
// RedefineClasses() has replaced this method; just return |
|
1251 |
if (method->is_old()) { |
|
1252 |
return NULL; |
|
1253 |
} |
|
1254 |
||
1255 |
// JVMTI -- post_compile_event requires jmethod_id() that may require |
|
1256 |
// a lock the compiling thread can not acquire. Prefetch it here. |
|
1257 |
if (JvmtiExport::should_post_compiled_method_load()) { |
|
1258 |
method->jmethod_id(); |
|
1259 |
} |
|
1260 |
||
1261 |
// do the compilation |
|
1262 |
if (method->is_native()) { |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13195
diff
changeset
|
1263 |
if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) { |
32391
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1264 |
// The following native methods: |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1265 |
// |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1266 |
// java.lang.Float.intBitsToFloat |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1267 |
// java.lang.Float.floatToRawIntBits |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1268 |
// java.lang.Double.longBitsToDouble |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1269 |
// java.lang.Double.doubleToRawLongBits |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1270 |
// |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1271 |
// are called through the interpreter even if interpreter native stubs |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1272 |
// are not preferred (i.e., calling through adapter handlers is preferred). |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1273 |
// The reason is that on x86_32 signaling NaNs (sNaNs) are not preserved |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1274 |
// if the version of the methods from the native libraries is called. |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1275 |
// As the interpreter and the C2-intrinsified version of the methods preserves |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1276 |
// sNaNs, that would result in an inconsistent way of handling of sNaNs. |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1277 |
if ((UseSSE >= 1 && |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1278 |
(method->intrinsic_id() == vmIntrinsics::_intBitsToFloat || |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1279 |
method->intrinsic_id() == vmIntrinsics::_floatToRawIntBits)) || |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1280 |
(UseSSE >= 2 && |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1281 |
(method->intrinsic_id() == vmIntrinsics::_longBitsToDouble || |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1282 |
method->intrinsic_id() == vmIntrinsics::_doubleToRawLongBits))) { |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1283 |
return NULL; |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1284 |
} |
01e2f5e916c7
8076373: In 32-bit VM interpreter and compiled code process NaN values differently
zmajo
parents:
31981
diff
changeset
|
1285 |
|
21098
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1286 |
// To properly handle the appendix argument for out-of-line calls we are using a small trampoline that |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1287 |
// pops off the appendix argument and jumps to the target (see gen_special_dispatch in SharedRuntime). |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1288 |
// |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1289 |
// Since normal compiled-to-compiled calls are not able to handle such a thing we MUST generate an adapter |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1290 |
// in this case. If we can't generate one and use it we can not execute the out-of-line method handle calls. |
22247 | 1291 |
AdapterHandlerLibrary::create_native_wrapper(method); |
1 | 1292 |
} else { |
1293 |
return NULL; |
|
1294 |
} |
|
1295 |
} else { |
|
21098
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1296 |
// If the compiler is shut off due to code cache getting full |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1297 |
// fail out now so blocking compiles dont hang the java thread |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1298 |
if (!should_compile_new_jobs()) { |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1299 |
CompilationPolicy::policy()->delay_compilation(method()); |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1300 |
return NULL; |
1820670a3362
8026407: VM crashes on linux-ppc and linux-i586 when there is not enough ReservedCodeCacheSize specified
anoll
parents:
20707
diff
changeset
|
1301 |
} |
52934
8deeb7bba516
8214917: CTW testlibrary shouldn't ignore errors raised by the library itself
iignatyev
parents:
52605
diff
changeset
|
1302 |
bool is_blocking = !directive->BackgroundCompilationOption || ReplayCompiles; |
38218 | 1303 |
compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, compile_reason, is_blocking, THREAD); |
1 | 1304 |
} |
1305 |
||
1306 |
// return requested nmethod |
|
6453 | 1307 |
// We accept a higher level osr method |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1308 |
if (osr_bci == InvocationEntryBci) { |
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1309 |
CompiledMethod* code = method->code(); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1310 |
if (code == NULL) { |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1311 |
return (nmethod*) code; |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1312 |
} else { |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1313 |
return code->as_nmethod_or_null(); |
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1314 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1315 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1316 |
return method->lookup_osr_nmethod_for(osr_bci, comp_level, false); |
1 | 1317 |
} |
1318 |
||
1319 |
||
1320 |
// ------------------------------------------------------------------ |
|
1321 |
// CompileBroker::compilation_is_complete |
|
1322 |
// |
|
1323 |
// See if compilation of this method is already complete. |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1324 |
bool CompileBroker::compilation_is_complete(const methodHandle& method, |
33626 | 1325 |
int osr_bci, |
1326 |
int comp_level) { |
|
1 | 1327 |
bool is_osr = (osr_bci != standard_entry_bci); |
1328 |
if (is_osr) { |
|
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
1329 |
if (method->is_not_osr_compilable(comp_level)) { |
1 | 1330 |
return true; |
1331 |
} else { |
|
6453 | 1332 |
nmethod* result = method->lookup_osr_nmethod_for(osr_bci, comp_level, true); |
1 | 1333 |
return (result != NULL); |
1334 |
} |
|
1335 |
} else { |
|
1336 |
if (method->is_not_compilable(comp_level)) { |
|
1337 |
return true; |
|
1338 |
} else { |
|
38133
78b95467b9f1
8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents:
38036
diff
changeset
|
1339 |
CompiledMethod* result = method->code(); |
1 | 1340 |
if (result == NULL) return false; |
6453 | 1341 |
return comp_level == result->comp_level(); |
1 | 1342 |
} |
1343 |
} |
|
1344 |
} |
|
1345 |
||
1346 |
||
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1347 |
/** |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1348 |
* See if this compilation is already requested. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1349 |
* |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1350 |
* Implementation note: there is only a single "is in queue" bit |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1351 |
* for each method. This means that the check below is overly |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1352 |
* conservative in the sense that an osr compilation in the queue |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1353 |
* will block a normal compilation from entering the queue (and vice |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1354 |
* versa). This can be remedied by a full queue search to disambiguate |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1355 |
* cases. If it is deemed profitable, this may be done. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1356 |
*/ |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1357 |
bool CompileBroker::compilation_is_in_queue(const methodHandle& method) { |
1 | 1358 |
return method->queued_for_compilation(); |
1359 |
} |
|
1360 |
||
1361 |
// ------------------------------------------------------------------ |
|
1362 |
// CompileBroker::compilation_is_prohibited |
|
1363 |
// |
|
1364 |
// See if this compilation is not allowed. |
|
36597
ee256e343585
8150646: Add support for blocking compiles though whitebox API
simonis
parents:
36322
diff
changeset
|
1365 |
bool CompileBroker::compilation_is_prohibited(const methodHandle& method, int osr_bci, int comp_level, bool excluded) { |
1 | 1366 |
bool is_native = method->is_native(); |
1367 |
// Some compilers may not support the compilation of natives. |
|
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
1368 |
AbstractCompiler *comp = compiler(comp_level); |
1 | 1369 |
if (is_native && |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
1370 |
(!CICompileNatives || comp == NULL || !comp->supports_native())) { |
6453 | 1371 |
method->set_not_compilable_quietly(comp_level); |
1 | 1372 |
return true; |
1373 |
} |
|
1374 |
||
1375 |
bool is_osr = (osr_bci != standard_entry_bci); |
|
1376 |
// Some compilers may not support on stack replacement. |
|
1377 |
if (is_osr && |
|
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
1378 |
(!CICompileOSR || comp == NULL || !comp->supports_osr())) { |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
1379 |
method->set_not_osr_compilable(comp_level); |
1 | 1380 |
return true; |
1381 |
} |
|
1382 |
||
1383 |
// The method may be explicitly excluded by the user. |
|
28650
772aaab2582f
8059606: Enable per-method usage of CompileThresholdScaling (per-method compilation thresholds)
zmajo
parents:
28501
diff
changeset
|
1384 |
double scale; |
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1385 |
if (excluded || (CompilerOracle::has_option_value(method, "CompileThresholdScaling", scale) && scale == 0)) { |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1386 |
bool quietly = CompilerOracle::should_exclude_quietly(); |
33478
e119795bddb7
8140581: Excluding compile messages should only be printed with PrintCompilation
neliasso
parents:
33451
diff
changeset
|
1387 |
if (PrintCompilation && !quietly) { |
1 | 1388 |
// This does not happen quietly... |
1389 |
ResourceMark rm; |
|
1390 |
tty->print("### Excluding %s:%s", |
|
1391 |
method->is_native() ? "generation of native wrapper" : "compile", |
|
1392 |
(method->is_static() ? " static" : "")); |
|
1393 |
method->print_short_name(tty); |
|
1394 |
tty->cr(); |
|
1395 |
} |
|
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1396 |
method->set_not_compilable(comp_level, !quietly, "excluded by CompileCommand"); |
1 | 1397 |
} |
1398 |
||
1399 |
return false; |
|
1400 |
} |
|
1401 |
||
22247 | 1402 |
/** |
1403 |
* Generate serialized IDs for compilation requests. If certain debugging flags are used |
|
1404 |
* and the ID is not within the specified range, the method is not compiled and 0 is returned. |
|
1405 |
* The function also allows to generate separate compilation IDs for OSR compilations. |
|
1406 |
*/ |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1407 |
int CompileBroker::assign_compile_id(const methodHandle& method, int osr_bci) { |
22247 | 1408 |
#ifdef ASSERT |
1 | 1409 |
bool is_osr = (osr_bci != standard_entry_bci); |
22247 | 1410 |
int id; |
1411 |
if (method->is_native()) { |
|
1412 |
assert(!is_osr, "can't be osr"); |
|
1413 |
// Adapters, native wrappers and method handle intrinsics |
|
1414 |
// should be generated always. |
|
1415 |
return Atomic::add(1, &_compilation_id); |
|
1416 |
} else if (CICountOSR && is_osr) { |
|
1417 |
id = Atomic::add(1, &_osr_compilation_id); |
|
1418 |
if (CIStartOSR <= id && id < CIStopOSR) { |
|
1 | 1419 |
return id; |
1420 |
} |
|
1421 |
} else { |
|
22247 | 1422 |
id = Atomic::add(1, &_compilation_id); |
1423 |
if (CIStart <= id && id < CIStop) { |
|
1 | 1424 |
return id; |
1425 |
} |
|
1426 |
} |
|
1427 |
||
1428 |
// Method was not in the appropriate compilation range. |
|
4756
da88c27a9241
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
4750
diff
changeset
|
1429 |
method->set_not_compilable_quietly(); |
1 | 1430 |
return 0; |
22247 | 1431 |
#else |
1432 |
// CICountOSR is a develop flag and set to 'false' by default. In a product built, |
|
1433 |
// only _compilation_id is incremented. |
|
1434 |
return Atomic::add(1, &_compilation_id); |
|
1435 |
#endif |
|
1 | 1436 |
} |
1437 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1438 |
// ------------------------------------------------------------------ |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1439 |
// CompileBroker::assign_compile_id_unlocked |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1440 |
// |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1441 |
// Public wrapper for assign_compile_id that acquires the needed locks |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1442 |
uint CompileBroker::assign_compile_id_unlocked(Thread* thread, const methodHandle& method, int osr_bci) { |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1443 |
MutexLocker locker(MethodCompileQueue_lock, thread); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1444 |
return assign_compile_id(method, osr_bci); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1445 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1446 |
|
1 | 1447 |
// ------------------------------------------------------------------ |
1448 |
// CompileBroker::preload_classes |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
1449 |
void CompileBroker::preload_classes(const methodHandle& method, TRAPS) { |
1 | 1450 |
// Move this code over from c1_Compiler.cpp |
1451 |
ShouldNotReachHere(); |
|
1452 |
} |
|
1453 |
||
1454 |
||
1455 |
// ------------------------------------------------------------------ |
|
1456 |
// CompileBroker::create_compile_task |
|
1457 |
// |
|
1458 |
// Create a CompileTask object representing the current request for |
|
1459 |
// compilation. Add this task to the queue. |
|
33626 | 1460 |
CompileTask* CompileBroker::create_compile_task(CompileQueue* queue, |
1461 |
int compile_id, |
|
1462 |
const methodHandle& method, |
|
1463 |
int osr_bci, |
|
1464 |
int comp_level, |
|
1465 |
const methodHandle& hot_method, |
|
1466 |
int hot_count, |
|
38218 | 1467 |
CompileTask::CompileReason compile_reason, |
33626 | 1468 |
bool blocking) { |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1469 |
CompileTask* new_task = CompileTask::allocate(); |
1 | 1470 |
new_task->initialize(compile_id, method, osr_bci, comp_level, |
38218 | 1471 |
hot_method, hot_count, compile_reason, |
1 | 1472 |
blocking); |
1473 |
queue->add(new_task); |
|
1474 |
return new_task; |
|
1475 |
} |
|
1476 |
||
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1477 |
#if INCLUDE_JVMCI |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1478 |
// The number of milliseconds to wait before checking if |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1479 |
// JVMCI compilation has made progress. |
49469
1708db7f94c6
8199624: [Graal] Blocking jvmci compilations time out
thartmann
parents:
49449
diff
changeset
|
1480 |
static const long JVMCI_COMPILATION_PROGRESS_WAIT_TIMESLICE = 1000; |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1481 |
|
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1482 |
// The number of JVMCI compilation progress checks that must fail |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1483 |
// before unblocking a thread waiting for a blocking compilation. |
49469
1708db7f94c6
8199624: [Graal] Blocking jvmci compilations time out
thartmann
parents:
49449
diff
changeset
|
1484 |
static const int JVMCI_COMPILATION_PROGRESS_WAIT_ATTEMPTS = 10; |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1485 |
|
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1486 |
/** |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1487 |
* Waits for a JVMCI compiler to complete a given task. This thread |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1488 |
* waits until either the task completes or it sees no JVMCI compilation |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1489 |
* progress for N consecutive milliseconds where N is |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1490 |
* JVMCI_COMPILATION_PROGRESS_WAIT_TIMESLICE * |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1491 |
* JVMCI_COMPILATION_PROGRESS_WAIT_ATTEMPTS. |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1492 |
* |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1493 |
* @return true if this thread needs to free/recycle the task |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1494 |
*/ |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1495 |
bool CompileBroker::wait_for_jvmci_completion(JVMCICompiler* jvmci, CompileTask* task, JavaThread* thread) { |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
1496 |
MonitorLocker ml(task->lock(), thread); |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1497 |
int progress_wait_attempts = 0; |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1498 |
int methods_compiled = jvmci->methods_compiled(); |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1499 |
while (!task->is_complete() && !is_compilation_disabled_forever() && |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
1500 |
ml.wait(JVMCI_COMPILATION_PROGRESS_WAIT_TIMESLICE)) { |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1501 |
CompilerThread* jvmci_compiler_thread = task->jvmci_compiler_thread(); |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1502 |
|
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1503 |
bool progress; |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1504 |
if (jvmci_compiler_thread != NULL) { |
52336
9ae99ef38c16
8195627: [Graal] nsk/jdi/VirtualMachine/redefineClasses/redefineclasses026 hangs with Graal in Xcomp mode
dtitov
parents:
52025
diff
changeset
|
1505 |
// If the JVMCI compiler thread is not blocked or suspended, we deem it to be making progress. |
9ae99ef38c16
8195627: [Graal] nsk/jdi/VirtualMachine/redefineClasses/redefineclasses026 hangs with Graal in Xcomp mode
dtitov
parents:
52025
diff
changeset
|
1506 |
progress = jvmci_compiler_thread->thread_state() != _thread_blocked && |
9ae99ef38c16
8195627: [Graal] nsk/jdi/VirtualMachine/redefineClasses/redefineclasses026 hangs with Graal in Xcomp mode
dtitov
parents:
52025
diff
changeset
|
1507 |
!jvmci_compiler_thread->is_external_suspend(); |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1508 |
} else { |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1509 |
// Still waiting on JVMCI compiler queue. This thread may be holding a lock |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1510 |
// that all JVMCI compiler threads are blocked on. We use the counter for |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1511 |
// successful JVMCI compilations to determine whether JVMCI compilation |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1512 |
// is still making progress through the JVMCI compiler queue. |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1513 |
progress = jvmci->methods_compiled() != methods_compiled; |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1514 |
} |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1515 |
|
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1516 |
if (!progress) { |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1517 |
if (++progress_wait_attempts == JVMCI_COMPILATION_PROGRESS_WAIT_ATTEMPTS) { |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1518 |
if (PrintCompilation) { |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1519 |
task->print(tty, "wait for blocking compilation timed out"); |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1520 |
} |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1521 |
break; |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1522 |
} |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1523 |
} else { |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1524 |
progress_wait_attempts = 0; |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1525 |
if (jvmci_compiler_thread == NULL) { |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1526 |
methods_compiled = jvmci->methods_compiled(); |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1527 |
} |
35547
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1528 |
} |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1529 |
} |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1530 |
task->clear_waiter(); |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1531 |
return task->is_complete(); |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1532 |
} |
0ee84aa8e705
8146705: Improve JVMCI support for blocking compilation
dnsimon
parents:
35135
diff
changeset
|
1533 |
#endif |
1 | 1534 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1535 |
/** |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1536 |
* Wait for the compilation task to complete. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1537 |
*/ |
1 | 1538 |
void CompileBroker::wait_for_completion(CompileTask* task) { |
1539 |
if (CIPrintCompileQueue) { |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1540 |
ttyLocker ttyl; |
1 | 1541 |
tty->print_cr("BLOCKING FOR COMPILE"); |
1542 |
} |
|
1543 |
||
1544 |
assert(task->is_blocking(), "can only wait on blocking task"); |
|
1545 |
||
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1546 |
JavaThread* thread = JavaThread::current(); |
1 | 1547 |
thread->set_blocked_on_compilation(true); |
1548 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1549 |
methodHandle method(thread, task->method()); |
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1550 |
bool free_task; |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1551 |
#if INCLUDE_JVMCI |
35845
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1552 |
AbstractCompiler* comp = compiler(task->comp_level()); |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1553 |
if (comp->is_jvmci()) { |
30025047885d
8148507: [JVMCI] mitigate deadlocks related to JVMCI compiler under -Xbatch
dnsimon
parents:
35825
diff
changeset
|
1554 |
free_task = wait_for_jvmci_completion((JVMCICompiler*) comp, task, thread); |
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1555 |
} else |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1556 |
#endif |
1 | 1557 |
{ |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
1558 |
MonitorLocker ml(task->lock(), thread); |
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1559 |
free_task = true; |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1560 |
while (!task->is_complete() && !is_compilation_disabled_forever()) { |
54645
05aaccf7d558
8222988: Use MonitorLocker rather than MutexLocker when wait/notify used
coleenp
parents:
54623
diff
changeset
|
1561 |
ml.wait(); |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1562 |
} |
1 | 1563 |
} |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1564 |
|
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1565 |
thread->set_blocked_on_compilation(false); |
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1566 |
if (free_task) { |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1567 |
if (is_compilation_disabled_forever()) { |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1568 |
CompileTask::free(task); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1569 |
return; |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1570 |
} |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1571 |
|
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1572 |
// It is harmless to check this status without the lock, because |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1573 |
// completion is a stable property (until the task object is recycled). |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1574 |
assert(task->is_complete(), "Compilation should have completed"); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1575 |
assert(task->code_handle() == NULL, "must be reset"); |
1 | 1576 |
|
34196
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1577 |
// By convention, the waiter is responsible for recycling a |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1578 |
// blocking CompileTask. Since there is only one waiter ever |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1579 |
// waiting on a CompileTask, we know that no one else will |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1580 |
// be using this CompileTask; we can free it. |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1581 |
CompileTask::free(task); |
72152eea3d39
8141330: [JVMCI] avoid deadlock between application thread and JVMCI compiler thread under -Xbatch
twisti
parents:
34195
diff
changeset
|
1582 |
} |
1 | 1583 |
} |
1584 |
||
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1585 |
/** |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1586 |
* Initialize compiler thread(s) + compiler object(s). The postcondition |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1587 |
* of this function is that the compiler runtimes are initialized and that |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1588 |
* compiler threads can start compiling. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1589 |
*/ |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1590 |
bool CompileBroker::init_compiler_runtime() { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1591 |
CompilerThread* thread = CompilerThread::current(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1592 |
AbstractCompiler* comp = thread->compiler(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1593 |
// Final sanity check - the compiler object must exist |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1594 |
guarantee(comp != NULL, "Compiler object must exist"); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1595 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1596 |
int system_dictionary_modification_counter; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1597 |
{ |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1598 |
MutexLocker locker(Compile_lock, thread); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1599 |
system_dictionary_modification_counter = SystemDictionary::number_of_modifications(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1600 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1601 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1602 |
{ |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1603 |
// Must switch to native to allocate ci_env |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1604 |
ThreadToNativeFromVM ttn(thread); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1605 |
ciEnv ci_env(NULL, system_dictionary_modification_counter); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1606 |
// Cache Jvmti state |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1607 |
ci_env.cache_jvmti_state(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1608 |
// Cache DTrace flags |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1609 |
ci_env.cache_dtrace_flags(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1610 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1611 |
// Switch back to VM state to do compiler initialization |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1612 |
ThreadInVMfromNative tv(thread); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1613 |
ResetNoHandleMark rnhm; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1614 |
|
47687 | 1615 |
// Perform per-thread and global initializations |
1616 |
comp->initialize(); |
|
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1617 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1618 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1619 |
if (comp->is_failed()) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1620 |
disable_compilation_forever(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1621 |
// If compiler initialization failed, no compiler thread that is specific to a |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1622 |
// particular compiler runtime will ever start to compile methods. |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1623 |
shutdown_compiler_runtime(comp, thread); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1624 |
return false; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1625 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1626 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1627 |
// C1 specific check |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1628 |
if (comp->is_c1() && (thread->get_buffer_blob() == NULL)) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1629 |
warning("Initialization of %s thread failed (no space to run compilers)", thread->name()); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1630 |
return false; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1631 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1632 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1633 |
return true; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1634 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1635 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1636 |
/** |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1637 |
* If C1 and/or C2 initialization failed, we shut down all compilation. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1638 |
* We do this to keep things simple. This can be changed if it ever turns |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1639 |
* out to be a problem. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1640 |
*/ |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1641 |
void CompileBroker::shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread) { |
51572
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1642 |
// Free buffer blob, if allocated |
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1643 |
if (thread->get_buffer_blob() != NULL) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
1644 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
51572
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1645 |
CodeCache::free(thread->get_buffer_blob()); |
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1646 |
} |
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1647 |
|
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1648 |
if (comp->should_perform_shutdown()) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1649 |
// There are two reasons for shutting down the compiler |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1650 |
// 1) compiler runtime initialization failed |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1651 |
// 2) The code cache is full and the following flag is set: -XX:-UseCodeCacheFlushing |
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1652 |
warning("%s initialization failed. Shutting down all compilers", comp->name()); |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1653 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1654 |
// Only one thread per compiler runtime object enters here |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1655 |
// Set state to shut down |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1656 |
comp->set_shut_down(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1657 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1658 |
// Delete all queued compilation tasks to make compiler threads exit faster. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1659 |
if (_c1_compile_queue != NULL) { |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1660 |
_c1_compile_queue->free_all(); |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1661 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1662 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1663 |
if (_c2_compile_queue != NULL) { |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1664 |
_c2_compile_queue->free_all(); |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1665 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1666 |
|
24321
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1667 |
// Set flags so that we continue execution with using interpreter only. |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1668 |
UseCompiler = false; |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1669 |
UseInterpreter = true; |
621f7e09fc0a
8040798: compiler/startup/SmallCodeCacheStartup.java timed out in RT_Baseline
anoll
parents:
22881
diff
changeset
|
1670 |
|
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1671 |
// We could delete compiler runtimes also. However, there are references to |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1672 |
// the compiler runtime(s) (e.g., nmethod::is_compiled_by_c1()) which then |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1673 |
// fail. This can be done later if necessary. |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1674 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1675 |
} |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1676 |
|
49848 | 1677 |
/** |
1678 |
* Helper function to create new or reuse old CompileLog. |
|
1679 |
*/ |
|
1680 |
CompileLog* CompileBroker::get_log(CompilerThread* ct) { |
|
1681 |
if (!LogCompilation) return NULL; |
|
1682 |
||
1683 |
AbstractCompiler *compiler = ct->compiler(); |
|
1684 |
bool c1 = compiler->is_c1(); |
|
1685 |
jobject* compiler_objects = c1 ? _compiler1_objects : _compiler2_objects; |
|
1686 |
assert(compiler_objects != NULL, "must be initialized at this point"); |
|
1687 |
CompileLog** logs = c1 ? _compiler1_logs : _compiler2_logs; |
|
1688 |
assert(logs != NULL, "must be initialized at this point"); |
|
1689 |
int count = c1 ? _c1_count : _c2_count; |
|
1690 |
||
1691 |
// Find Compiler number by its threadObj. |
|
1692 |
oop compiler_obj = ct->threadObj(); |
|
1693 |
int compiler_number = 0; |
|
1694 |
bool found = false; |
|
1695 |
for (; compiler_number < count; compiler_number++) { |
|
1696 |
if (oopDesc::equals(JNIHandles::resolve_non_null(compiler_objects[compiler_number]), compiler_obj)) { |
|
1697 |
found = true; |
|
1698 |
break; |
|
1699 |
} |
|
1700 |
} |
|
1701 |
assert(found, "Compiler must exist at this point"); |
|
1702 |
||
1703 |
// Determine pointer for this thread's log. |
|
1704 |
CompileLog** log_ptr = &logs[compiler_number]; |
|
1705 |
||
1706 |
// Return old one if it exists. |
|
1707 |
CompileLog* log = *log_ptr; |
|
1708 |
if (log != NULL) { |
|
1709 |
ct->init_log(log); |
|
1710 |
return log; |
|
1711 |
} |
|
1712 |
||
1713 |
// Create a new one and remember it. |
|
1714 |
init_compiler_thread_log(); |
|
1715 |
log = ct->log(); |
|
1716 |
*log_ptr = log; |
|
1717 |
return log; |
|
1718 |
} |
|
1719 |
||
1 | 1720 |
// ------------------------------------------------------------------ |
1721 |
// CompileBroker::compiler_thread_loop |
|
1722 |
// |
|
1723 |
// The main loop run by a CompilerThread. |
|
1724 |
void CompileBroker::compiler_thread_loop() { |
|
1725 |
CompilerThread* thread = CompilerThread::current(); |
|
1726 |
CompileQueue* queue = thread->queue(); |
|
1727 |
// For the thread that initializes the ciObjectFactory |
|
1728 |
// this resource mark holds all the shared objects |
|
1729 |
ResourceMark rm; |
|
1730 |
||
1731 |
// First thread to get here will initialize the compiler interface |
|
1732 |
||
45621 | 1733 |
{ |
1 | 1734 |
ASSERT_IN_VM; |
1735 |
MutexLocker only_one (CompileThread_lock, thread); |
|
1736 |
if (!ciObjectFactory::is_initialized()) { |
|
1737 |
ciObjectFactory::initialize(); |
|
1738 |
} |
|
1739 |
} |
|
1740 |
||
1741 |
// Open a log. |
|
49848 | 1742 |
CompileLog* log = get_log(thread); |
1 | 1743 |
if (log != NULL) { |
13964 | 1744 |
log->begin_elem("start_compile_thread name='%s' thread='" UINTX_FORMAT "' process='%d'", |
1745 |
thread->name(), |
|
1 | 1746 |
os::current_thread_id(), |
1747 |
os::current_process_id()); |
|
1748 |
log->stamp(); |
|
1749 |
log->end_elem(); |
|
1750 |
} |
|
1751 |
||
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1752 |
// If compiler thread/runtime initialization fails, exit the compiler thread |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1753 |
if (!init_compiler_runtime()) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1754 |
return; |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1755 |
} |
4750 | 1756 |
|
49848 | 1757 |
thread->start_idle_timer(); |
1758 |
||
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1759 |
// Poll for new compilation tasks as long as the JVM runs. Compilation |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1760 |
// should only be disabled if something went wrong while initializing the |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1761 |
// compiler runtimes. This, in turn, should not happen. The only known case |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1762 |
// when compiler runtime initialization fails is if there is not enough free |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1763 |
// space in the code cache to generate the necessary stubs, etc. |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1764 |
while (!is_compilation_disabled_forever()) { |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1765 |
// We need this HandleMark to avoid leaking VM handles. |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1766 |
HandleMark hm(thread); |
1 | 1767 |
|
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1768 |
CompileTask* task = queue->get(); |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1769 |
if (task == NULL) { |
49848 | 1770 |
if (UseDynamicNumberOfCompilerThreads) { |
1771 |
// Access compiler_count under lock to enforce consistency. |
|
1772 |
MutexLocker only_one(CompileThread_lock); |
|
1773 |
if (can_remove(thread, true)) { |
|
1774 |
if (TraceCompilerThreads) { |
|
1775 |
tty->print_cr("Removing compiler thread %s after " JLONG_FORMAT " ms idle time", |
|
1776 |
thread->name(), thread->idle_time_millis()); |
|
1777 |
} |
|
51572
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1778 |
// Free buffer blob, if allocated |
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1779 |
if (thread->get_buffer_blob() != NULL) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
1780 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
51572
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1781 |
CodeCache::free(thread->get_buffer_blob()); |
d2137bd1e57d
8209670: CompilerThread releasing code buffer in destructor is unsafe
thartmann
parents:
51026
diff
changeset
|
1782 |
} |
49848 | 1783 |
return; // Stop this thread. |
1784 |
} |
|
1785 |
} |
|
52025 | 1786 |
} else { |
1787 |
// Assign the task to the current thread. Mark this compilation |
|
1788 |
// thread as active for the profiler. |
|
1789 |
// CompileTaskWrapper also keeps the Method* from being deallocated if redefinition |
|
1790 |
// occurs after fetching the compile task off the queue. |
|
1791 |
CompileTaskWrapper ctw(task); |
|
1792 |
nmethodLocker result_handle; // (handle for the nmethod produced by this task) |
|
1793 |
task->set_code_handle(&result_handle); |
|
1794 |
methodHandle method(thread, task->method()); |
|
49848 | 1795 |
|
52025 | 1796 |
// Never compile a method if breakpoints are present in it |
1797 |
if (method()->number_of_breakpoints() == 0) { |
|
1798 |
// Compile the method. |
|
1799 |
if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) { |
|
1800 |
invoke_compiler_on_method(task); |
|
1801 |
thread->start_idle_timer(); |
|
1802 |
} else { |
|
1803 |
// After compilation is disabled, remove remaining methods from queue |
|
1804 |
method->clear_queued_for_compilation(); |
|
1805 |
task->set_failure_reason("compilation is disabled"); |
|
1806 |
} |
|
1807 |
} |
|
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1808 |
|
52025 | 1809 |
if (UseDynamicNumberOfCompilerThreads) { |
1810 |
possibly_add_compiler_threads(); |
|
1 | 1811 |
} |
1812 |
} |
|
1813 |
} |
|
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1814 |
|
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1815 |
// Shut down compiler runtime |
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
1816 |
shutdown_compiler_runtime(thread->compiler(), thread); |
1 | 1817 |
} |
1818 |
||
1819 |
// ------------------------------------------------------------------ |
|
1820 |
// CompileBroker::init_compiler_thread_log |
|
1821 |
// |
|
1822 |
// Set up state required by +LogCompilation. |
|
1823 |
void CompileBroker::init_compiler_thread_log() { |
|
1824 |
CompilerThread* thread = CompilerThread::current(); |
|
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1825 |
char file_name[4*K]; |
1 | 1826 |
FILE* fp = NULL; |
1827 |
intx thread_id = os::current_thread_id(); |
|
1828 |
for (int try_temp_dir = 1; try_temp_dir >= 0; try_temp_dir--) { |
|
1829 |
const char* dir = (try_temp_dir ? os::get_temp_directory() : NULL); |
|
5237
aab592fd4f44
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
5051
diff
changeset
|
1830 |
if (dir == NULL) { |
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1831 |
jio_snprintf(file_name, sizeof(file_name), "hs_c" UINTX_FORMAT "_pid%u.log", |
5237
aab592fd4f44
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
5051
diff
changeset
|
1832 |
thread_id, os::current_process_id()); |
aab592fd4f44
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
5051
diff
changeset
|
1833 |
} else { |
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1834 |
jio_snprintf(file_name, sizeof(file_name), |
5237
aab592fd4f44
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
5051
diff
changeset
|
1835 |
"%s%shs_c" UINTX_FORMAT "_pid%u.log", dir, |
aab592fd4f44
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
5051
diff
changeset
|
1836 |
os::file_separator(), thread_id, os::current_process_id()); |
aab592fd4f44
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
5051
diff
changeset
|
1837 |
} |
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1838 |
|
27709
e6f02d6fee44
8007993: hotspot.log w/ enabled LogCompilation can be an invalid XML
thartmann
parents:
27706
diff
changeset
|
1839 |
fp = fopen(file_name, "wt"); |
1 | 1840 |
if (fp != NULL) { |
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1841 |
if (LogCompilation && Verbose) { |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1842 |
tty->print_cr("Opening compilation log %s", file_name); |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1843 |
} |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1844 |
CompileLog* log = new(ResourceObj::C_HEAP, mtCompiler) CompileLog(file_name, fp, thread_id); |
36835
999bfb0219d6
8152730: File Leak in CompileBroker::init_compiler_thread_log of compileBroker.cpp:1665.
rraghavan
parents:
36807
diff
changeset
|
1845 |
if (log == NULL) { |
999bfb0219d6
8152730: File Leak in CompileBroker::init_compiler_thread_log of compileBroker.cpp:1665.
rraghavan
parents:
36807
diff
changeset
|
1846 |
fclose(fp); |
999bfb0219d6
8152730: File Leak in CompileBroker::init_compiler_thread_log of compileBroker.cpp:1665.
rraghavan
parents:
36807
diff
changeset
|
1847 |
return; |
999bfb0219d6
8152730: File Leak in CompileBroker::init_compiler_thread_log of compileBroker.cpp:1665.
rraghavan
parents:
36807
diff
changeset
|
1848 |
} |
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1849 |
thread->init_log(log); |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1850 |
|
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1851 |
if (xtty != NULL) { |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1852 |
ttyLocker ttyl; |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1853 |
// Record any per thread log files |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24350
diff
changeset
|
1854 |
xtty->elem("thread_logfile thread='" INTX_FORMAT "' filename='%s'", thread_id, file_name); |
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1855 |
} |
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1856 |
return; |
1 | 1857 |
} |
1858 |
} |
|
17876
7313e6d57e36
8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp
anoll
parents:
17383
diff
changeset
|
1859 |
warning("Cannot open log file: %s", file_name); |
1 | 1860 |
} |
1861 |
||
27461
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1862 |
void CompileBroker::log_metaspace_failure() { |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1863 |
const char* message = "some methods may not be compiled because metaspace " |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1864 |
"is out of memory"; |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1865 |
if (_compilation_log != NULL) { |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1866 |
_compilation_log->log_metaspace_failure(message); |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1867 |
} |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1868 |
if (PrintCompilation) { |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1869 |
tty->print_cr("COMPILE PROFILING SKIPPED: %s", message); |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1870 |
} |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1871 |
} |
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1872 |
|
90e9e0f9c0c5
8037842: Failing to allocate MethodCounters and MDO causes a serious performance drop
coleenp
parents:
26913
diff
changeset
|
1873 |
|
1 | 1874 |
// ------------------------------------------------------------------ |
1875 |
// CompileBroker::set_should_block |
|
1876 |
// |
|
1877 |
// Set _should_block. |
|
1878 |
// Call this from the VM, with Threads_lock held and a safepoint requested. |
|
1879 |
void CompileBroker::set_should_block() { |
|
1880 |
assert(Threads_lock->owner() == Thread::current(), "must have threads lock"); |
|
1881 |
assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint already"); |
|
1882 |
#ifndef PRODUCT |
|
1883 |
if (PrintCompilation && (Verbose || WizardMode)) |
|
1884 |
tty->print_cr("notifying compiler thread pool to block"); |
|
1885 |
#endif |
|
1886 |
_should_block = true; |
|
1887 |
} |
|
1888 |
||
1889 |
// ------------------------------------------------------------------ |
|
1890 |
// CompileBroker::maybe_block |
|
1891 |
// |
|
1892 |
// Call this from the compiler at convenient points, to poll for _should_block. |
|
1893 |
void CompileBroker::maybe_block() { |
|
1894 |
if (_should_block) { |
|
1895 |
#ifndef PRODUCT |
|
1896 |
if (PrintCompilation && (Verbose || WizardMode)) |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24350
diff
changeset
|
1897 |
tty->print_cr("compiler thread " INTPTR_FORMAT " poll detects block request", p2i(Thread::current())); |
1 | 1898 |
#endif |
1899 |
ThreadInVMfromNative tivfn(JavaThread::current()); |
|
1900 |
} |
|
1901 |
} |
|
1902 |
||
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1903 |
// wrapper for CodeCache::print_summary() |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1904 |
static void codecache_print(bool detailed) |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1905 |
{ |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1906 |
ResourceMark rm; |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1907 |
stringStream s; |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1908 |
// Dump code cache into a buffer before locking the tty, |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1909 |
{ |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
1910 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1911 |
CodeCache::print_summary(&s, detailed); |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1912 |
} |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1913 |
ttyLocker ttyl; |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24350
diff
changeset
|
1914 |
tty->print("%s", s.as_string()); |
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1915 |
} |
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
1916 |
|
46485 | 1917 |
// wrapper for CodeCache::print_summary() using outputStream |
1918 |
static void codecache_print(outputStream* out, bool detailed) { |
|
1919 |
ResourceMark rm; |
|
1920 |
stringStream s; |
|
1921 |
||
1922 |
// Dump code cache into a buffer |
|
1923 |
{ |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
1924 |
MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
46485 | 1925 |
CodeCache::print_summary(&s, detailed); |
1926 |
} |
|
1927 |
||
1928 |
char* remaining_log = s.as_string(); |
|
1929 |
while (*remaining_log != '\0') { |
|
1930 |
char* eol = strchr(remaining_log, '\n'); |
|
1931 |
if (eol == NULL) { |
|
1932 |
out->print_cr("%s", remaining_log); |
|
1933 |
remaining_log = remaining_log + strlen(remaining_log); |
|
1934 |
} else { |
|
1935 |
*eol = '\0'; |
|
1936 |
out->print_cr("%s", remaining_log); |
|
1937 |
remaining_log = eol + 1; |
|
1938 |
} |
|
1939 |
} |
|
1940 |
} |
|
1941 |
||
52605
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1942 |
void CompileBroker::post_compile(CompilerThread* thread, CompileTask* task, bool success, ciEnv* ci_env, |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1943 |
int compilable, const char* failure_reason) { |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1944 |
if (success) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1945 |
task->mark_success(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1946 |
if (ci_env != NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1947 |
task->set_num_inlined_bytecodes(ci_env->num_inlined_bytecodes()); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1948 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1949 |
if (_compilation_log != NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1950 |
nmethod* code = task->code(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1951 |
if (code != NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1952 |
_compilation_log->log_nmethod(thread, code); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1953 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1954 |
} |
52605
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1955 |
} else if (AbortVMOnCompilationFailure) { |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1956 |
if (compilable == ciEnv::MethodCompilable_not_at_tier) { |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1957 |
fatal("Not compilable at tier %d: %s", task->comp_level(), failure_reason); |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1958 |
} |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1959 |
if (compilable == ciEnv::MethodCompilable_never) { |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1960 |
fatal("Never compilable: %s", failure_reason); |
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
1961 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1962 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1963 |
// simulate crash during compilation |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1964 |
assert(task->compile_id() != CICrashAt, "just as planned"); |
50113 | 1965 |
} |
1966 |
||
1967 |
static void post_compilation_event(EventCompilation* event, CompileTask* task) { |
|
1968 |
assert(event != NULL, "invariant"); |
|
1969 |
assert(event->should_commit(), "invariant"); |
|
1970 |
event->set_method(task->method()); |
|
1971 |
event->set_compileId(task->compile_id()); |
|
1972 |
event->set_compileLevel(task->comp_level()); |
|
1973 |
event->set_succeded(task->is_success()); |
|
1974 |
event->set_isOsr(task->osr_bci() != CompileBroker::standard_entry_bci); |
|
1975 |
event->set_codeSize((task->code() == NULL) ? 0 : task->code()->total_size()); |
|
1976 |
event->set_inlinedBytes(task->num_inlined_bytecodes()); |
|
1977 |
event->commit(); |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1978 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
1979 |
|
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1980 |
int DirectivesStack::_depth = 0; |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1981 |
CompilerDirectives* DirectivesStack::_top = NULL; |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1982 |
CompilerDirectives* DirectivesStack::_bottom = NULL; |
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
1983 |
|
1 | 1984 |
// ------------------------------------------------------------------ |
1985 |
// CompileBroker::invoke_compiler_on_method |
|
1986 |
// |
|
1987 |
// Compile a method. |
|
1988 |
// |
|
1989 |
void CompileBroker::invoke_compiler_on_method(CompileTask* task) { |
|
46270 | 1990 |
task->print_ul(); |
1 | 1991 |
if (PrintCompilation) { |
1992 |
ResourceMark rm; |
|
26587 | 1993 |
task->print_tty(); |
1 | 1994 |
} |
1995 |
elapsedTimer time; |
|
1996 |
||
1997 |
CompilerThread* thread = CompilerThread::current(); |
|
1998 |
ResourceMark rm(thread); |
|
1999 |
||
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2000 |
if (LogEvents) { |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2001 |
_compilation_log->log_compile(thread, task); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2002 |
} |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2003 |
|
1 | 2004 |
// Common flags. |
2005 |
uint compile_id = task->compile_id(); |
|
2006 |
int osr_bci = task->osr_bci(); |
|
2007 |
bool is_osr = (osr_bci != standard_entry_bci); |
|
2008 |
bool should_log = (thread->log() != NULL); |
|
2009 |
bool should_break = false; |
|
37281
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
2010 |
const int task_level = task->comp_level(); |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
2011 |
AbstractCompiler* comp = task->compiler(); |
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
2012 |
|
34191
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2013 |
DirectiveSet* directive; |
1 | 2014 |
{ |
2015 |
// create the handle inside it's own block so it can't |
|
2016 |
// accidentally be referenced once the thread transitions to |
|
2017 |
// native. The NoHandleMark before the transition should catch |
|
2018 |
// any cases where this occurs in the future. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2019 |
methodHandle method(thread, task->method()); |
1 | 2020 |
assert(!method->is_native(), "no longer compile natives"); |
2021 |
||
34191
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2022 |
// Look up matching directives |
37281
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
2023 |
directive = DirectivesStack::getMatchingDirective(method, comp); |
34191
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2024 |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2025 |
// Update compile information when using perfdata. |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2026 |
if (UsePerfData) { |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2027 |
update_compile_perf_data(thread, method, is_osr); |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2028 |
} |
1 | 2029 |
|
17133
ef4dd2f8fcb1
8013532: Remove unused parameter "compiler" from DTRACE_METHOD_COMPILE* macros
roland
parents:
17132
diff
changeset
|
2030 |
DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, compiler_name(task_level)); |
1 | 2031 |
} |
2032 |
||
34191
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2033 |
should_break = directive->BreakAtExecuteOption || task->check_break_at_flags(); |
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2034 |
if (should_log && !directive->LogOption) { |
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2035 |
should_log = false; |
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2036 |
} |
8287a25df277
8141585: CompilerDirectivesDCMDTest intermittently SEGVs in MethodMatcher::matcher
neliasso
parents:
34185
diff
changeset
|
2037 |
|
1 | 2038 |
// Allocate a new set of JNI handles. |
2039 |
push_jni_handle_block(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2040 |
Method* target_handle = task->method(); |
1 | 2041 |
int compilable = ciEnv::MethodCompilable; |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2042 |
const char* failure_reason = NULL; |
53417
126c5e7b97b1
8217445: [JVMCI] incorrect management of JVMCI compilation failure reason string
dnsimon
parents:
53406
diff
changeset
|
2043 |
bool failure_reason_on_C_heap = false; |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2044 |
const char* retry_message = NULL; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2045 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2046 |
int system_dictionary_modification_counter; |
1 | 2047 |
{ |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2048 |
MutexLocker locker(Compile_lock, thread); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2049 |
system_dictionary_modification_counter = SystemDictionary::number_of_modifications(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2050 |
} |
37281
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36835
diff
changeset
|
2051 |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2052 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2053 |
if (UseJVMCICompiler && comp != NULL && comp->is_jvmci()) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2054 |
JVMCICompiler* jvmci = (JVMCICompiler*) comp; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2055 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2056 |
TraceTime t1("compilation", &time); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2057 |
EventCompilation event; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2058 |
|
48400
8604408bc26e
8193323: Crash in "failed dependencies, but counter didn't change" with enabled UseJVMCICompiler
dlong
parents:
47765
diff
changeset
|
2059 |
// Skip redefined methods |
8604408bc26e
8193323: Crash in "failed dependencies, but counter didn't change" with enabled UseJVMCICompiler
dlong
parents:
47765
diff
changeset
|
2060 |
if (target_handle->is_old()) { |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2061 |
failure_reason = "redefined method"; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2062 |
retry_message = "not retryable"; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2063 |
compilable = ciEnv::MethodCompilable_never; |
48400
8604408bc26e
8193323: Crash in "failed dependencies, but counter didn't change" with enabled UseJVMCICompiler
dlong
parents:
47765
diff
changeset
|
2064 |
} else { |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2065 |
JVMCICompileState compile_state(task, system_dictionary_modification_counter); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2066 |
JVMCIEnv env(&compile_state, __FILE__, __LINE__); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2067 |
methodHandle method(thread, target_handle); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2068 |
env.runtime()->compile_method(&env, jvmci, method, osr_bci); |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2069 |
|
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2070 |
failure_reason = compile_state.failure_reason(); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2071 |
failure_reason_on_C_heap = compile_state.failure_reason_on_C_heap(); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2072 |
if (!compile_state.retryable()) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2073 |
retry_message = "not retryable"; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2074 |
compilable = ciEnv::MethodCompilable_not_at_tier; |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2075 |
} |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2076 |
if (task->code() == NULL) { |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2077 |
assert(failure_reason != NULL, "must specify failure_reason"); |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54645
diff
changeset
|
2078 |
} |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2079 |
} |
52605
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
2080 |
post_compile(thread, task, task->code() != NULL, NULL, compilable, failure_reason); |
50113 | 2081 |
if (event.should_commit()) { |
2082 |
post_compilation_event(&event, task); |
|
2083 |
} |
|
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2084 |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2085 |
} else |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2086 |
#endif // INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2087 |
{ |
1 | 2088 |
NoHandleMark nhm; |
2089 |
ThreadToNativeFromVM ttn(thread); |
|
2090 |
||
2091 |
ciEnv ci_env(task, system_dictionary_modification_counter); |
|
2092 |
if (should_break) { |
|
2093 |
ci_env.set_break_at_compile(true); |
|
2094 |
} |
|
2095 |
if (should_log) { |
|
2096 |
ci_env.set_log(thread->log()); |
|
2097 |
} |
|
2098 |
assert(thread->env() == &ci_env, "set by ci_env"); |
|
2099 |
// The thread-env() field is cleared in ~CompileTaskWrapper. |
|
2100 |
||
2867
69187054225f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
1
diff
changeset
|
2101 |
// Cache Jvmti state |
69187054225f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
1
diff
changeset
|
2102 |
ci_env.cache_jvmti_state(); |
69187054225f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
1
diff
changeset
|
2103 |
|
69187054225f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
1
diff
changeset
|
2104 |
// Cache DTrace flags |
69187054225f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
1
diff
changeset
|
2105 |
ci_env.cache_dtrace_flags(); |
69187054225f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
1
diff
changeset
|
2106 |
|
1 | 2107 |
ciMethod* target = ci_env.get_method_from_handle(target_handle); |
2108 |
||
2109 |
TraceTime t1("compilation", &time); |
|
18025 | 2110 |
EventCompilation event; |
1 | 2111 |
|
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2112 |
if (comp == NULL) { |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2113 |
ci_env.record_method_not_compilable("no compiler", !TieredCompilation); |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2114 |
} else { |
27642
8c9eff693145
8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents:
27464
diff
changeset
|
2115 |
if (WhiteBoxAPI && WhiteBox::compilation_locked) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
2116 |
MonitorLocker locker(Compilation_lock, Mutex::_no_safepoint_check_flag); |
27642
8c9eff693145
8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents:
27464
diff
changeset
|
2117 |
while (WhiteBox::compilation_locked) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
2118 |
locker.wait(); |
27642
8c9eff693145
8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents:
27464
diff
changeset
|
2119 |
} |
8c9eff693145
8059624: Test task: WhiteBox API for testing segmented codecache feature
iignatyev
parents:
27464
diff
changeset
|
2120 |
} |
33451
0712796e4039
8137167: JEP165: Compiler Control: Implementation task
neliasso
parents:
33198
diff
changeset
|
2121 |
comp->compile_method(&ci_env, target, osr_bci, directive); |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2122 |
} |
1 | 2123 |
|
2124 |
if (!ci_env.failing() && task->code() == NULL) { |
|
2125 |
//assert(false, "compiler should always document failure"); |
|
2126 |
// The compiler elected, without comment, not to register a result. |
|
2127 |
// Do not attempt further compilations of this method. |
|
7389
93110864f81e
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
6453
diff
changeset
|
2128 |
ci_env.record_method_not_compilable("compile failed", !TieredCompilation); |
1 | 2129 |
} |
2130 |
||
11636
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2131 |
// Copy this bit to the enclosing block: |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2132 |
compilable = ci_env.compilable(); |
3c07b54482a5
7141200: log some interesting information in ring buffers for crashes
never
parents:
11572
diff
changeset
|
2133 |
|
1 | 2134 |
if (ci_env.failing()) { |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2135 |
failure_reason = ci_env.failure_reason(); |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2136 |
retry_message = ci_env.retry_message(); |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2137 |
ci_env.report_failure(failure_reason); |
1 | 2138 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2139 |
|
52605
b8c88c64abf0
8212070: Introduce diagnostic flag to abort VM on failed JIT compilation
shade
parents:
52369
diff
changeset
|
2140 |
post_compile(thread, task, !ci_env.failing(), &ci_env, compilable, failure_reason); |
50113 | 2141 |
if (event.should_commit()) { |
2142 |
post_compilation_event(&event, task); |
|
2143 |
} |
|
1 | 2144 |
} |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2145 |
// Remove the JNI handle block after the ciEnv destructor has run in |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2146 |
// the previous block. |
1 | 2147 |
pop_jni_handle_block(); |
2148 |
||
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2149 |
if (failure_reason != NULL) { |
53417
126c5e7b97b1
8217445: [JVMCI] incorrect management of JVMCI compilation failure reason string
dnsimon
parents:
53406
diff
changeset
|
2150 |
task->set_failure_reason(failure_reason, failure_reason_on_C_heap); |
35592
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2151 |
if (_compilation_log != NULL) { |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2152 |
_compilation_log->log_failure(thread, task, failure_reason, retry_message); |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2153 |
} |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2154 |
if (PrintCompilation) { |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2155 |
FormatBufferResource msg = retry_message != NULL ? |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2156 |
FormatBufferResource("COMPILE SKIPPED: %s (%s)", failure_reason, retry_message) : |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2157 |
FormatBufferResource("COMPILE SKIPPED: %s", failure_reason); |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2158 |
task->print(tty, msg); |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2159 |
} |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2160 |
} |
5814f874d736
8147432: JVMCI should report bailouts in PrintCompilation output
never
parents:
35576
diff
changeset
|
2161 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2162 |
methodHandle method(thread, task->method()); |
1 | 2163 |
|
17133
ef4dd2f8fcb1
8013532: Remove unused parameter "compiler" from DTRACE_METHOD_COMPILE* macros
roland
parents:
17132
diff
changeset
|
2164 |
DTRACE_METHOD_COMPILE_END_PROBE(method, compiler_name(task_level), task->is_success()); |
1 | 2165 |
|
2166 |
collect_statistics(thread, time, task); |
|
2167 |
||
36078
954c49c0ba57
8149969: [JVMCI] PrintNMethods is ignored for CompilerToVM.installCode when not called from the broker
never
parents:
35845
diff
changeset
|
2168 |
nmethod* nm = task->code(); |
954c49c0ba57
8149969: [JVMCI] PrintNMethods is ignored for CompilerToVM.installCode when not called from the broker
never
parents:
35845
diff
changeset
|
2169 |
if (nm != NULL) { |
954c49c0ba57
8149969: [JVMCI] PrintNMethods is ignored for CompilerToVM.installCode when not called from the broker
never
parents:
35845
diff
changeset
|
2170 |
nm->maybe_print_nmethod(directive); |
35576 | 2171 |
} |
2172 |
DirectivesStack::release(directive); |
|
2173 |
||
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10971
diff
changeset
|
2174 |
if (PrintCompilation && PrintCompilation2) { |
10971 | 2175 |
tty->print("%7d ", (int) tty->time_stamp().milliseconds()); // print timestamp |
2176 |
tty->print("%4d ", compile_id); // print compilation number |
|
2177 |
tty->print("%s ", (is_osr ? "%" : " ")); |
|
17383 | 2178 |
if (task->code() != NULL) { |
2179 |
tty->print("size: %d(%d) ", task->code()->total_size(), task->code()->insts_size()); |
|
2180 |
} |
|
2181 |
tty->print_cr("time: %d inlined: %d bytes", (int)time.milliseconds(), task->num_inlined_bytecodes()); |
|
10971 | 2182 |
} |
2183 |
||
46485 | 2184 |
Log(compilation, codecache) log; |
2185 |
if (log.is_debug()) { |
|
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46632
diff
changeset
|
2186 |
LogStream ls(log.debug()); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46632
diff
changeset
|
2187 |
codecache_print(&ls, /* detailed= */ false); |
46485 | 2188 |
} |
2189 |
if (PrintCodeCacheOnCompilation) { |
|
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
2190 |
codecache_print(/* detailed= */ false); |
46485 | 2191 |
} |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2192 |
// Disable compilation, if required. |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2193 |
switch (compilable) { |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2194 |
case ciEnv::MethodCompilable_never: |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2195 |
if (is_osr) |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2196 |
method->set_not_osr_compilable_quietly(); |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2197 |
else |
4756
da88c27a9241
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
4750
diff
changeset
|
2198 |
method->set_not_compilable_quietly(); |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2199 |
break; |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2200 |
case ciEnv::MethodCompilable_not_at_tier: |
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2201 |
if (is_osr) |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2202 |
method->set_not_osr_compilable_quietly(task_level); |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2203 |
else |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2204 |
method->set_not_compilable_quietly(task_level); |
13891
35dabd293e56
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
13738
diff
changeset
|
2205 |
break; |
1 | 2206 |
} |
2207 |
||
2208 |
// Note that the queued_for_compilation bits are cleared without |
|
2209 |
// protection of a mutex. [They were set by the requester thread, |
|
24443
7aaf1b306b55
8023461: Thread holding lock at safepoint that vm can block on: MethodCompileQueue_lock
vlivanov
parents:
24424
diff
changeset
|
2210 |
// when adding the task to the compile queue -- at which time the |
1 | 2211 |
// compile queue lock was held. Subsequently, we acquired the compile |
2212 |
// queue lock to get this task off the compile queue; thus (to belabour |
|
2213 |
// the point somewhat) our clearing of the bits must be occurring |
|
2214 |
// only after the setting of the bits. See also 14012000 above. |
|
2215 |
method->clear_queued_for_compilation(); |
|
2216 |
} |
|
2217 |
||
21575
6a9645992cee
8027593: performance drop with constrained codecache starting with hs25 b111
anoll
parents:
21204
diff
changeset
|
2218 |
/** |
27420
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
2219 |
* The CodeCache is full. Print warning and disable compilation. |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
2220 |
* Schedule code cache cleaning so compilation can continue later. |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
2221 |
* This function needs to be called only from CodeCache::allocate(), |
04e6f914cce1
8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents:
26913
diff
changeset
|
2222 |
* since we currently handle a full code cache uniformly. |
21575
6a9645992cee
8027593: performance drop with constrained codecache starting with hs25 b111
anoll
parents:
21204
diff
changeset
|
2223 |
*/ |
26796 | 2224 |
void CompileBroker::handle_full_code_cache(int code_blob_type) { |
4750 | 2225 |
UseInterpreter = true; |
2226 |
if (UseCompiler || AlwaysCompileLoopMethods ) { |
|
6270
d628c75fbf48
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
6187
diff
changeset
|
2227 |
if (xtty != NULL) { |
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
2228 |
ResourceMark rm; |
9138
35e4b04eadf4
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
9103
diff
changeset
|
2229 |
stringStream s; |
35e4b04eadf4
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
9103
diff
changeset
|
2230 |
// Dump code cache state into a buffer before locking the tty, |
35e4b04eadf4
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
9103
diff
changeset
|
2231 |
// because log_state() will use locks causing lock conflicts. |
35e4b04eadf4
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
9103
diff
changeset
|
2232 |
CodeCache::log_state(&s); |
35e4b04eadf4
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
9103
diff
changeset
|
2233 |
// Lock to prevent tearing |
35e4b04eadf4
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
9103
diff
changeset
|
2234 |
ttyLocker ttyl; |
6270
d628c75fbf48
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
6187
diff
changeset
|
2235 |
xtty->begin_elem("code_cache_full"); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24350
diff
changeset
|
2236 |
xtty->print("%s", s.as_string()); |
6270
d628c75fbf48
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
6187
diff
changeset
|
2237 |
xtty->stamp(); |
d628c75fbf48
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
6187
diff
changeset
|
2238 |
xtty->end_elem(); |
4750 | 2239 |
} |
18025 | 2240 |
|
5701
bb5bb5d5e19f
6930994: Code cache is full warning should be visible in product
never
parents:
5533
diff
changeset
|
2241 |
#ifndef PRODUCT |
52934
8deeb7bba516
8214917: CTW testlibrary shouldn't ignore errors raised by the library itself
iignatyev
parents:
52605
diff
changeset
|
2242 |
if (ExitOnFullCodeCache) { |
15201
f3d755b11424
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
14816
diff
changeset
|
2243 |
codecache_print(/* detailed= */ true); |
4750 | 2244 |
before_exit(JavaThread::current()); |
2245 |
exit_globals(); // will delete tty |
|
52934
8deeb7bba516
8214917: CTW testlibrary shouldn't ignore errors raised by the library itself
iignatyev
parents:
52605
diff
changeset
|
2246 |
vm_direct_exit(1); |
4750 | 2247 |
} |
5701
bb5bb5d5e19f
6930994: Code cache is full warning should be visible in product
never
parents:
5533
diff
changeset
|
2248 |
#endif |
4750 | 2249 |
if (UseCodeCacheFlushing) { |
20290
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
2250 |
// Since code cache is full, immediately stop new compiles |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
2251 |
if (CompileBroker::set_should_compile_new_jobs(CompileBroker::stop_compilation)) { |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
2252 |
NMethodSweeper::log_sweep("disable_compiler"); |
2127dc70bce9
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
19708
diff
changeset
|
2253 |
} |
4750 | 2254 |
} else { |
20707
b3b658c6d1f8
8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents:
20688
diff
changeset
|
2255 |
disable_compilation_forever(); |
4750 | 2256 |
} |
21575
6a9645992cee
8027593: performance drop with constrained codecache starting with hs25 b111
anoll
parents:
21204
diff
changeset
|
2257 |
|
26796 | 2258 |
CodeCache::report_codemem_full(code_blob_type, should_print_compiler_warning()); |
4750 | 2259 |
} |
2260 |
} |
|
2261 |
||
2262 |
// ------------------------------------------------------------------ |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2263 |
// CompileBroker::update_compile_perf_data |
1 | 2264 |
// |
2265 |
// Record this compilation for debugging purposes. |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2266 |
void CompileBroker::update_compile_perf_data(CompilerThread* thread, const methodHandle& method, bool is_osr) { |
1 | 2267 |
ResourceMark rm; |
2268 |
char* method_name = method->name()->as_C_string(); |
|
2269 |
char current_method[CompilerCounters::cmname_buffer_length]; |
|
2270 |
size_t maxLen = CompilerCounters::cmname_buffer_length; |
|
2271 |
||
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2272 |
const char* class_name = method->method_holder()->name()->as_C_string(); |
1 | 2273 |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2274 |
size_t s1len = strlen(class_name); |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2275 |
size_t s2len = strlen(method_name); |
1 | 2276 |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2277 |
// check if we need to truncate the string |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2278 |
if (s1len + s2len + 2 > maxLen) { |
1 | 2279 |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2280 |
// the strategy is to lop off the leading characters of the |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2281 |
// class name and the trailing characters of the method name. |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2282 |
|
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2283 |
if (s2len + 2 > maxLen) { |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2284 |
// lop of the entire class name string, let snprintf handle |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2285 |
// truncation of the method name. |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2286 |
class_name += s1len; // null string |
1 | 2287 |
} |
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2288 |
else { |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2289 |
// lop off the extra characters from the front of the class name |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2290 |
class_name += ((s1len + s2len + 2) - maxLen); |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2291 |
} |
1 | 2292 |
} |
2293 |
||
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2294 |
jio_snprintf(current_method, maxLen, "%s %s", class_name, method_name); |
1 | 2295 |
|
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2296 |
int last_compile_type = normal_compile; |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2297 |
if (CICountOSR && is_osr) { |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2298 |
last_compile_type = osr_compile; |
1 | 2299 |
} |
54482
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2300 |
|
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2301 |
CompilerCounters* counters = thread->counters(); |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2302 |
counters->set_current_method(current_method); |
c914170817d4
8221853: Data race in compile broker (set_last_compile)
jcbeyler
parents:
54015
diff
changeset
|
2303 |
counters->set_compile_type((jlong) last_compile_type); |
1 | 2304 |
} |
2305 |
||
2306 |
// ------------------------------------------------------------------ |
|
2307 |
// CompileBroker::push_jni_handle_block |
|
2308 |
// |
|
2309 |
// Push on a new block of JNI handles. |
|
2310 |
void CompileBroker::push_jni_handle_block() { |
|
2311 |
JavaThread* thread = JavaThread::current(); |
|
2312 |
||
2313 |
// Allocate a new block for JNI handles. |
|
2314 |
// Inlined code from jni_PushLocalFrame() |
|
2315 |
JNIHandleBlock* java_handles = thread->active_handles(); |
|
2316 |
JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread); |
|
2317 |
assert(compile_handles != NULL && java_handles != NULL, "should not be NULL"); |
|
2318 |
compile_handles->set_pop_frame_link(java_handles); // make sure java handles get gc'd. |
|
2319 |
thread->set_active_handles(compile_handles); |
|
2320 |
} |
|
2321 |
||
2322 |
||
2323 |
// ------------------------------------------------------------------ |
|
2324 |
// CompileBroker::pop_jni_handle_block |
|
2325 |
// |
|
2326 |
// Pop off the current block of JNI handles. |
|
2327 |
void CompileBroker::pop_jni_handle_block() { |
|
2328 |
JavaThread* thread = JavaThread::current(); |
|
2329 |
||
2330 |
// Release our JNI handle block |
|
2331 |
JNIHandleBlock* compile_handles = thread->active_handles(); |
|
2332 |
JNIHandleBlock* java_handles = compile_handles->pop_frame_link(); |
|
2333 |
thread->set_active_handles(java_handles); |
|
2334 |
compile_handles->set_pop_frame_link(NULL); |
|
2335 |
JNIHandleBlock::release_block(compile_handles, thread); // may block |
|
2336 |
} |
|
2337 |
||
2338 |
// ------------------------------------------------------------------ |
|
2339 |
// CompileBroker::collect_statistics |
|
2340 |
// |
|
2341 |
// Collect statistics about the compilation. |
|
2342 |
||
2343 |
void CompileBroker::collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task) { |
|
2344 |
bool success = task->is_success(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2345 |
methodHandle method (thread, task->method()); |
1 | 2346 |
uint compile_id = task->compile_id(); |
2347 |
bool is_osr = (task->osr_bci() != standard_entry_bci); |
|
2348 |
nmethod* code = task->code(); |
|
2349 |
CompilerCounters* counters = thread->counters(); |
|
2350 |
||
2351 |
assert(code == NULL || code->is_locked_by_vm(), "will survive the MutexLocker"); |
|
2352 |
MutexLocker locker(CompileStatistics_lock); |
|
2353 |
||
2354 |
// _perf variables are production performance counters which are |
|
2355 |
// updated regardless of the setting of the CITime and CITimeEach flags |
|
2356 |
// |
|
26913 | 2357 |
|
2358 |
// account all time, including bailouts and failures in this counter; |
|
2359 |
// C1 and C2 counters are counting both successful and unsuccessful compiles |
|
2360 |
_t_total_compilation.add(time); |
|
2361 |
||
1 | 2362 |
if (!success) { |
2363 |
_total_bailout_count++; |
|
2364 |
if (UsePerfData) { |
|
2365 |
_perf_last_failed_method->set_value(counters->current_method()); |
|
2366 |
_perf_last_failed_type->set_value(counters->compile_type()); |
|
2367 |
_perf_total_bailout_count->inc(); |
|
2368 |
} |
|
26913 | 2369 |
_t_bailedout_compilation.add(time); |
1 | 2370 |
} else if (code == NULL) { |
2371 |
if (UsePerfData) { |
|
2372 |
_perf_last_invalidated_method->set_value(counters->current_method()); |
|
2373 |
_perf_last_invalidated_type->set_value(counters->compile_type()); |
|
2374 |
_perf_total_invalidated_count->inc(); |
|
2375 |
} |
|
2376 |
_total_invalidated_count++; |
|
26913 | 2377 |
_t_invalidated_compilation.add(time); |
1 | 2378 |
} else { |
2379 |
// Compilation succeeded |
|
2380 |
||
2381 |
// update compilation ticks - used by the implementation of |
|
2382 |
// java.lang.management.CompilationMBean |
|
2383 |
_perf_total_compilation->inc(time.ticks()); |
|
18025 | 2384 |
_peak_compilation_time = time.milliseconds() > _peak_compilation_time ? time.milliseconds() : _peak_compilation_time; |
2385 |
||
1 | 2386 |
if (CITime) { |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2387 |
int bytes_compiled = method->code_size() + task->num_inlined_bytecodes(); |
1 | 2388 |
if (is_osr) { |
2389 |
_t_osr_compilation.add(time); |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2390 |
_sum_osr_bytes_compiled += bytes_compiled; |
1 | 2391 |
} else { |
2392 |
_t_standard_compilation.add(time); |
|
2393 |
_sum_standard_bytes_compiled += method->code_size() + task->num_inlined_bytecodes(); |
|
2394 |
} |
|
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2395 |
|
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2396 |
#if INCLUDE_JVMCI |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2397 |
AbstractCompiler* comp = compiler(task->comp_level()); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2398 |
if (comp) { |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2399 |
CompilerStatistics* stats = comp->stats(); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2400 |
if (stats) { |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2401 |
if (is_osr) { |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2402 |
stats->_osr.update(time, bytes_compiled); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2403 |
} else { |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2404 |
stats->_standard.update(time, bytes_compiled); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2405 |
} |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2406 |
stats->_nmethods_size += code->total_size(); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2407 |
stats->_nmethods_code_size += code->insts_size(); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2408 |
} else { // if (!stats) |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2409 |
assert(false, "Compiler statistics object must exist"); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2410 |
} |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2411 |
} else { // if (!comp) |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2412 |
assert(false, "Compiler object must exist"); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2413 |
} |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2414 |
#endif // INCLUDE_JVMCI |
1 | 2415 |
} |
2416 |
||
2417 |
if (UsePerfData) { |
|
2418 |
// save the name of the last method compiled |
|
2419 |
_perf_last_method->set_value(counters->current_method()); |
|
2420 |
_perf_last_compile_type->set_value(counters->compile_type()); |
|
2421 |
_perf_last_compile_size->set_value(method->code_size() + |
|
2422 |
task->num_inlined_bytecodes()); |
|
2423 |
if (is_osr) { |
|
2424 |
_perf_osr_compilation->inc(time.ticks()); |
|
2425 |
_perf_sum_osr_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes()); |
|
2426 |
} else { |
|
2427 |
_perf_standard_compilation->inc(time.ticks()); |
|
2428 |
_perf_sum_standard_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes()); |
|
2429 |
} |
|
2430 |
} |
|
2431 |
||
2432 |
if (CITimeEach) { |
|
2433 |
float bytes_per_sec = 1.0 * (method->code_size() + task->num_inlined_bytecodes()) / time.seconds(); |
|
2434 |
tty->print_cr("%3d seconds: %f bytes/sec : %f (bytes %d + %d inlined)", |
|
2435 |
compile_id, time.seconds(), bytes_per_sec, method->code_size(), task->num_inlined_bytecodes()); |
|
2436 |
} |
|
2437 |
||
2438 |
// Collect counts of successful compilations |
|
6418 | 2439 |
_sum_nmethod_size += code->total_size(); |
2440 |
_sum_nmethod_code_size += code->insts_size(); |
|
1 | 2441 |
_total_compile_count++; |
2442 |
||
2443 |
if (UsePerfData) { |
|
6418 | 2444 |
_perf_sum_nmethod_size->inc( code->total_size()); |
2445 |
_perf_sum_nmethod_code_size->inc(code->insts_size()); |
|
1 | 2446 |
_perf_total_compile_count->inc(); |
2447 |
} |
|
2448 |
||
2449 |
if (is_osr) { |
|
2450 |
if (UsePerfData) _perf_total_osr_compile_count->inc(); |
|
2451 |
_total_osr_compile_count++; |
|
2452 |
} else { |
|
2453 |
if (UsePerfData) _perf_total_standard_compile_count->inc(); |
|
2454 |
_total_standard_compile_count++; |
|
2455 |
} |
|
2456 |
} |
|
2457 |
// set the current method for the thread to null |
|
2458 |
if (UsePerfData) counters->set_current_method(""); |
|
2459 |
} |
|
2460 |
||
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2461 |
const char* CompileBroker::compiler_name(int comp_level) { |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2462 |
AbstractCompiler *comp = CompileBroker::compiler(comp_level); |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2463 |
if (comp == NULL) { |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2464 |
return "no compiler"; |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2465 |
} else { |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2466 |
return (comp->name()); |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2467 |
} |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2468 |
} |
1 | 2469 |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2470 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2471 |
void CompileBroker::print_times(AbstractCompiler* comp) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2472 |
CompilerStatistics* stats = comp->stats(); |
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2473 |
if (stats) { |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2474 |
tty->print_cr(" %s {speed: %d bytes/s; standard: %6.3f s, %d bytes, %d methods; osr: %6.3f s, %d bytes, %d methods; nmethods_size: %d bytes; nmethods_code_size: %d bytes}", |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2475 |
comp->name(), stats->bytes_per_second(), |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2476 |
stats->_standard._time.seconds(), stats->_standard._bytes, stats->_standard._count, |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2477 |
stats->_osr._time.seconds(), stats->_osr._bytes, stats->_osr._count, |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2478 |
stats->_nmethods_size, stats->_nmethods_code_size); |
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2479 |
} else { // if (!stats) |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2480 |
assert(false, "Compiler statistics object must exist"); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2481 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2482 |
comp->print_timers(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2483 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2484 |
#endif // INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2485 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2486 |
void CompileBroker::print_times(bool per_compiler, bool aggregate) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2487 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2488 |
elapsedTimer standard_compilation; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2489 |
elapsedTimer total_compilation; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2490 |
elapsedTimer osr_compilation; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2491 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2492 |
int standard_bytes_compiled = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2493 |
int osr_bytes_compiled = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2494 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2495 |
int standard_compile_count = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2496 |
int osr_compile_count = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2497 |
int total_compile_count = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2498 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2499 |
int nmethods_size = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2500 |
int nmethods_code_size = 0; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2501 |
bool printedHeader = false; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2502 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2503 |
for (unsigned int i = 0; i < sizeof(_compilers) / sizeof(AbstractCompiler*); i++) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2504 |
AbstractCompiler* comp = _compilers[i]; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2505 |
if (comp != NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2506 |
if (per_compiler && aggregate && !printedHeader) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2507 |
printedHeader = true; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2508 |
tty->cr(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2509 |
tty->print_cr("Individual compiler times (for compiled methods only)"); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2510 |
tty->print_cr("------------------------------------------------"); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2511 |
tty->cr(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2512 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2513 |
CompilerStatistics* stats = comp->stats(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2514 |
|
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2515 |
if (stats) { |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2516 |
standard_compilation.add(stats->_standard._time); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2517 |
osr_compilation.add(stats->_osr._time); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2518 |
|
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2519 |
standard_bytes_compiled += stats->_standard._bytes; |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2520 |
osr_bytes_compiled += stats->_osr._bytes; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2521 |
|
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2522 |
standard_compile_count += stats->_standard._count; |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2523 |
osr_compile_count += stats->_osr._count; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2524 |
|
36299
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2525 |
nmethods_size += stats->_nmethods_size; |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2526 |
nmethods_code_size += stats->_nmethods_code_size; |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2527 |
} else { // if (!stats) |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2528 |
assert(false, "Compiler statistics object must exist"); |
3d75bb0d749b
8145707: 4 Null pointer dereference defect groups in compileBroker.cpp.
thartmann
parents:
36078
diff
changeset
|
2529 |
} |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2530 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2531 |
if (per_compiler) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2532 |
print_times(comp); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2533 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2534 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2535 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2536 |
total_compile_count = osr_compile_count + standard_compile_count; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2537 |
total_compilation.add(osr_compilation); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2538 |
total_compilation.add(standard_compilation); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2539 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2540 |
// In hosted mode, print the JVMCI compiler specific counters manually. |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2541 |
if (!UseJVMCICompiler) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2542 |
JVMCICompiler::print_compilation_timers(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2543 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2544 |
#else // INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2545 |
elapsedTimer standard_compilation = CompileBroker::_t_standard_compilation; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2546 |
elapsedTimer osr_compilation = CompileBroker::_t_osr_compilation; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2547 |
elapsedTimer total_compilation = CompileBroker::_t_total_compilation; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2548 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2549 |
int standard_bytes_compiled = CompileBroker::_sum_standard_bytes_compiled; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2550 |
int osr_bytes_compiled = CompileBroker::_sum_osr_bytes_compiled; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2551 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2552 |
int standard_compile_count = CompileBroker::_total_standard_compile_count; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2553 |
int osr_compile_count = CompileBroker::_total_osr_compile_count; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2554 |
int total_compile_count = CompileBroker::_total_compile_count; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2555 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2556 |
int nmethods_size = CompileBroker::_sum_nmethod_code_size; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2557 |
int nmethods_code_size = CompileBroker::_sum_nmethod_size; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2558 |
#endif // INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2559 |
|
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2560 |
if (!aggregate) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2561 |
return; |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2562 |
} |
1 | 2563 |
tty->cr(); |
26913 | 2564 |
tty->print_cr("Accumulated compiler times"); |
2565 |
tty->print_cr("----------------------------------------------------------"); |
|
1 | 2566 |
//0000000000111111111122222222223333333333444444444455555555556666666666 |
2567 |
//0123456789012345678901234567890123456789012345678901234567890123456789 |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2568 |
tty->print_cr(" Total compilation time : %7.3f s", total_compilation.seconds()); |
26913 | 2569 |
tty->print_cr(" Standard compilation : %7.3f s, Average : %2.3f s", |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2570 |
standard_compilation.seconds(), |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2571 |
standard_compilation.seconds() / standard_compile_count); |
26913 | 2572 |
tty->print_cr(" Bailed out compilation : %7.3f s, Average : %2.3f s", |
2573 |
CompileBroker::_t_bailedout_compilation.seconds(), |
|
2574 |
CompileBroker::_t_bailedout_compilation.seconds() / CompileBroker::_total_bailout_count); |
|
2575 |
tty->print_cr(" On stack replacement : %7.3f s, Average : %2.3f s", |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2576 |
osr_compilation.seconds(), |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2577 |
osr_compilation.seconds() / osr_compile_count); |
26913 | 2578 |
tty->print_cr(" Invalidated : %7.3f s, Average : %2.3f s", |
2579 |
CompileBroker::_t_invalidated_compilation.seconds(), |
|
2580 |
CompileBroker::_t_invalidated_compilation.seconds() / CompileBroker::_total_invalidated_count); |
|
4560 | 2581 |
|
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2582 |
AbstractCompiler *comp = compiler(CompLevel_simple); |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2583 |
if (comp != NULL) { |
26913 | 2584 |
tty->cr(); |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2585 |
comp->print_timers(); |
1 | 2586 |
} |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2587 |
comp = compiler(CompLevel_full_optimization); |
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2588 |
if (comp != NULL) { |
26913 | 2589 |
tty->cr(); |
16372
20c2c4dc8b77
8008663: [parfait] Null pointer deference in hotspot/src/share/vm/compiler/compileBroker.cpp
morris
parents:
15946
diff
changeset
|
2590 |
comp->print_timers(); |
6453 | 2591 |
} |
1 | 2592 |
tty->cr(); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2593 |
tty->print_cr(" Total compiled methods : %8d methods", total_compile_count); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2594 |
tty->print_cr(" Standard compilation : %8d methods", standard_compile_count); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2595 |
tty->print_cr(" On stack replacement : %8d methods", osr_compile_count); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2596 |
int tcb = osr_bytes_compiled + standard_bytes_compiled; |
26913 | 2597 |
tty->print_cr(" Total compiled bytecodes : %8d bytes", tcb); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2598 |
tty->print_cr(" Standard compilation : %8d bytes", standard_bytes_compiled); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2599 |
tty->print_cr(" On stack replacement : %8d bytes", osr_bytes_compiled); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2600 |
double tcs = total_compilation.seconds(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2601 |
int bps = tcs == 0.0 ? 0 : (int)(tcb / tcs); |
26913 | 2602 |
tty->print_cr(" Average compilation speed : %8d bytes/s", bps); |
1 | 2603 |
tty->cr(); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2604 |
tty->print_cr(" nmethod code size : %8d bytes", nmethods_code_size); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
33069
diff
changeset
|
2605 |
tty->print_cr(" nmethod total size : %8d bytes", nmethods_size); |
1 | 2606 |
} |
2607 |
||
49611 | 2608 |
// Print general/accumulated JIT information. |
2609 |
void CompileBroker::print_info(outputStream *out) { |
|
2610 |
if (out == NULL) out = tty; |
|
2611 |
out->cr(); |
|
2612 |
out->print_cr("======================"); |
|
2613 |
out->print_cr(" General JIT info "); |
|
2614 |
out->print_cr("======================"); |
|
2615 |
out->cr(); |
|
2616 |
out->print_cr(" JIT is : %7s", should_compile_new_jobs() ? "on" : "off"); |
|
2617 |
out->print_cr(" Compiler threads : %7d", (int)CICompilerCount); |
|
2618 |
out->cr(); |
|
2619 |
out->print_cr("CodeCache overview"); |
|
2620 |
out->print_cr("--------------------------------------------------------"); |
|
2621 |
out->cr(); |
|
2622 |
out->print_cr(" Reserved size : " SIZE_FORMAT_W(7) " KB", CodeCache::max_capacity() / K); |
|
2623 |
out->print_cr(" Committed size : " SIZE_FORMAT_W(7) " KB", CodeCache::capacity() / K); |
|
2624 |
out->print_cr(" Unallocated capacity : " SIZE_FORMAT_W(7) " KB", CodeCache::unallocated_capacity() / K); |
|
2625 |
out->cr(); |
|
2626 |
||
2627 |
out->cr(); |
|
2628 |
out->print_cr("CodeCache cleaning overview"); |
|
2629 |
out->print_cr("--------------------------------------------------------"); |
|
2630 |
out->cr(); |
|
2631 |
NMethodSweeper::print(out); |
|
2632 |
out->print_cr("--------------------------------------------------------"); |
|
2633 |
out->cr(); |
|
2634 |
} |
|
2635 |
||
2636 |
// Note: tty_lock must not be held upon entry to this function. |
|
2637 |
// Print functions called from herein do "micro-locking" on tty_lock. |
|
2638 |
// That's a tradeoff which keeps together important blocks of output. |
|
2639 |
// At the same time, continuous tty_lock hold time is kept in check, |
|
2640 |
// preventing concurrently printing threads from stalling a long time. |
|
2641 |
void CompileBroker::print_heapinfo(outputStream* out, const char* function, const char* granularity) { |
|
2642 |
TimeStamp ts_total; |
|
53353 | 2643 |
TimeStamp ts_global; |
49611 | 2644 |
TimeStamp ts; |
2645 |
||
2646 |
bool allFun = !strcmp(function, "all"); |
|
2647 |
bool aggregate = !strcmp(function, "aggregate") || !strcmp(function, "analyze") || allFun; |
|
2648 |
bool usedSpace = !strcmp(function, "UsedSpace") || allFun; |
|
2649 |
bool freeSpace = !strcmp(function, "FreeSpace") || allFun; |
|
2650 |
bool methodCount = !strcmp(function, "MethodCount") || allFun; |
|
2651 |
bool methodSpace = !strcmp(function, "MethodSpace") || allFun; |
|
2652 |
bool methodAge = !strcmp(function, "MethodAge") || allFun; |
|
2653 |
bool methodNames = !strcmp(function, "MethodNames") || allFun; |
|
2654 |
bool discard = !strcmp(function, "discard") || allFun; |
|
2655 |
||
2656 |
if (out == NULL) { |
|
2657 |
out = tty; |
|
2658 |
} |
|
2659 |
||
2660 |
if (!(aggregate || usedSpace || freeSpace || methodCount || methodSpace || methodAge || methodNames || discard)) { |
|
2661 |
out->print_cr("\n__ CodeHeapStateAnalytics: Function %s is not supported", function); |
|
2662 |
out->cr(); |
|
2663 |
return; |
|
2664 |
} |
|
2665 |
||
2666 |
ts_total.update(); // record starting point |
|
2667 |
||
2668 |
if (aggregate) { |
|
2669 |
print_info(out); |
|
2670 |
} |
|
2671 |
||
2672 |
// We hold the CodeHeapStateAnalytics_lock all the time, from here until we leave this function. |
|
53353 | 2673 |
// That prevents another thread from destroying our view on the CodeHeap. |
49611 | 2674 |
// When we request individual parts of the analysis via the jcmd interface, it is possible |
2675 |
// that in between another thread (another jcmd user or the vm running into CodeCache OOM) |
|
2676 |
// updated the aggregated data. That's a tolerable tradeoff because we can't hold a lock |
|
2677 |
// across user interaction. |
|
53353 | 2678 |
// Acquire this lock before acquiring the CodeCache_lock. |
2679 |
// CodeHeapStateAnalytics_lock could be held by a concurrent thread for a long time, |
|
2680 |
// leading to an unnecessarily long hold time of the CodeCache_lock. |
|
49611 | 2681 |
ts.update(); // record starting point |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
2682 |
MutexLocker mu1(CodeHeapStateAnalytics_lock, Mutex::_no_safepoint_check_flag); |
53353 | 2683 |
out->print_cr("\n__ CodeHeapStateAnalytics lock wait took %10.3f seconds _________\n", ts.seconds()); |
2684 |
||
2685 |
// If we serve an "allFun" call, it is beneficial to hold the CodeCache_lock |
|
2686 |
// for the entire duration of aggregation and printing. That makes sure |
|
2687 |
// we see a consistent picture and do not run into issues caused by |
|
2688 |
// the CodeHeap being altered concurrently. |
|
2689 |
Monitor* global_lock = allFun ? CodeCache_lock : NULL; |
|
2690 |
Monitor* function_lock = allFun ? NULL : CodeCache_lock; |
|
2691 |
ts_global.update(); // record starting point |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
2692 |
MutexLocker mu2(global_lock, Mutex::_no_safepoint_check_flag); |
53353 | 2693 |
if (global_lock != NULL) { |
2694 |
out->print_cr("\n__ CodeCache (global) lock wait took %10.3f seconds _________\n", ts_global.seconds()); |
|
2695 |
ts_global.update(); // record starting point |
|
2696 |
} |
|
49611 | 2697 |
|
2698 |
if (aggregate) { |
|
2699 |
ts.update(); // record starting point |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
2700 |
MutexLocker mu3(function_lock, Mutex::_no_safepoint_check_flag); |
53353 | 2701 |
if (function_lock != NULL) { |
2702 |
out->print_cr("\n__ CodeCache (function) lock wait took %10.3f seconds _________\n", ts.seconds()); |
|
2703 |
} |
|
49611 | 2704 |
|
2705 |
ts.update(); // record starting point |
|
2706 |
CodeCache::aggregate(out, granularity); |
|
53353 | 2707 |
if (function_lock != NULL) { |
2708 |
out->print_cr("\n__ CodeCache (function) lock hold took %10.3f seconds _________\n", ts.seconds()); |
|
2709 |
} |
|
49611 | 2710 |
} |
2711 |
||
2712 |
if (usedSpace) CodeCache::print_usedSpace(out); |
|
2713 |
if (freeSpace) CodeCache::print_freeSpace(out); |
|
2714 |
if (methodCount) CodeCache::print_count(out); |
|
2715 |
if (methodSpace) CodeCache::print_space(out); |
|
2716 |
if (methodAge) CodeCache::print_age(out); |
|
53353 | 2717 |
if (methodNames) { |
2718 |
// print_names() has shown to be sensitive to concurrent CodeHeap modifications. |
|
2719 |
// Therefore, request the CodeCache_lock before calling... |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54482
diff
changeset
|
2720 |
MutexLocker mu3(function_lock, Mutex::_no_safepoint_check_flag); |
53353 | 2721 |
CodeCache::print_names(out); |
2722 |
} |
|
49611 | 2723 |
if (discard) CodeCache::discard(out); |
2724 |
||
53353 | 2725 |
if (global_lock != NULL) { |
2726 |
out->print_cr("\n__ CodeCache (global) lock hold took %10.3f seconds _________\n", ts_global.seconds()); |
|
2727 |
} |
|
2728 |
out->print_cr("\n__ CodeHeapStateAnalytics total duration %10.3f seconds _________\n", ts_total.seconds()); |
|
49611 | 2729 |
} |