Mercurial > hg > truffle
annotate src/share/vm/compiler/compileBroker.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | 9191895df19d |
| children | c3e799c37717 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1538
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1538
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1538
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "code/codeCache.hpp" | |
| 29 #include "compiler/compileBroker.hpp" | |
| 30 #include "compiler/compileLog.hpp" | |
| 31 #include "compiler/compilerOracle.hpp" | |
| 32 #include "interpreter/linkResolver.hpp" | |
| 33 #include "memory/allocation.inline.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
34 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
35 #include "oops/method.hpp" |
| 1972 | 36 #include "oops/oop.inline.hpp" |
| 37 #include "prims/nativeLookup.hpp" | |
| 38 #include "runtime/arguments.hpp" | |
| 39 #include "runtime/compilationPolicy.hpp" | |
| 40 #include "runtime/init.hpp" | |
| 41 #include "runtime/interfaceSupport.hpp" | |
| 42 #include "runtime/javaCalls.hpp" | |
| 43 #include "runtime/os.hpp" | |
| 44 #include "runtime/sharedRuntime.hpp" | |
| 45 #include "runtime/sweeper.hpp" | |
| 46 #include "utilities/dtrace.hpp" | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
47 #include "utilities/events.hpp" |
| 1972 | 48 #ifdef COMPILER1 |
| 49 #include "c1/c1_Compiler.hpp" | |
| 50 #endif | |
| 51 #ifdef COMPILER2 | |
| 52 #include "opto/c2compiler.hpp" | |
| 53 #endif | |
| 54 #ifdef SHARK | |
| 55 #include "shark/sharkCompiler.hpp" | |
| 56 #endif | |
| 0 | 57 |
| 58 #ifdef DTRACE_ENABLED | |
| 59 | |
| 60 // Only bother with this argument setup if dtrace is available | |
| 61 | |
| 4006 | 62 #ifndef USDT2 |
| 0 | 63 HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin, |
| 64 char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t); | |
| 65 HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end, | |
| 66 char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t, bool); | |
| 67 | |
| 68 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method) \ | |
| 69 { \ | |
| 70 char* comp_name = (char*)(compiler)->name(); \ | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
71 Symbol* klass_name = (method)->klass_name(); \ |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
72 Symbol* name = (method)->name(); \ |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
73 Symbol* signature = (method)->signature(); \ |
| 0 | 74 HS_DTRACE_PROBE8(hotspot, method__compile__begin, \ |
| 75 comp_name, strlen(comp_name), \ | |
| 76 klass_name->bytes(), klass_name->utf8_length(), \ | |
| 77 name->bytes(), name->utf8_length(), \ | |
| 78 signature->bytes(), signature->utf8_length()); \ | |
| 79 } | |
| 80 | |
| 81 #define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success) \ | |
| 82 { \ | |
| 83 char* comp_name = (char*)(compiler)->name(); \ | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
84 Symbol* klass_name = (method)->klass_name(); \ |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
85 Symbol* name = (method)->name(); \ |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
86 Symbol* signature = (method)->signature(); \ |
| 0 | 87 HS_DTRACE_PROBE9(hotspot, method__compile__end, \ |
| 88 comp_name, strlen(comp_name), \ | |
| 89 klass_name->bytes(), klass_name->utf8_length(), \ | |
| 90 name->bytes(), name->utf8_length(), \ | |
| 91 signature->bytes(), signature->utf8_length(), (success)); \ | |
| 92 } | |
| 93 | |
| 4006 | 94 #else /* USDT2 */ |
| 95 | |
| 96 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method) \ | |
| 97 { \ | |
| 98 char* comp_name = (char*)(compiler)->name(); \ | |
| 99 Symbol* klass_name = (method)->klass_name(); \ | |
| 100 Symbol* name = (method)->name(); \ | |
| 101 Symbol* signature = (method)->signature(); \ | |
| 102 HOTSPOT_METHOD_COMPILE_BEGIN( \ | |
| 103 comp_name, strlen(comp_name), \ | |
| 104 (char *) klass_name->bytes(), klass_name->utf8_length(), \ | |
| 105 (char *) name->bytes(), name->utf8_length(), \ | |
| 106 (char *) signature->bytes(), signature->utf8_length()); \ | |
| 107 } | |
| 108 | |
| 109 #define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success) \ | |
| 110 { \ | |
| 111 char* comp_name = (char*)(compiler)->name(); \ | |
| 112 Symbol* klass_name = (method)->klass_name(); \ | |
| 113 Symbol* name = (method)->name(); \ | |
| 114 Symbol* signature = (method)->signature(); \ | |
| 115 HOTSPOT_METHOD_COMPILE_END( \ | |
| 116 comp_name, strlen(comp_name), \ | |
| 117 (char *) klass_name->bytes(), klass_name->utf8_length(), \ | |
| 118 (char *) name->bytes(), name->utf8_length(), \ | |
| 119 (char *) signature->bytes(), signature->utf8_length(), (success)); \ | |
| 120 } | |
| 121 #endif /* USDT2 */ | |
| 122 | |
| 0 | 123 #else // ndef DTRACE_ENABLED |
| 124 | |
| 125 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method) | |
| 126 #define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success) | |
| 127 | |
| 128 #endif // ndef DTRACE_ENABLED | |
| 129 | |
| 130 bool CompileBroker::_initialized = false; | |
| 131 volatile bool CompileBroker::_should_block = false; | |
| 1202 | 132 volatile jint CompileBroker::_should_compile_new_jobs = run_compilation; |
| 0 | 133 |
| 134 // The installed compiler(s) | |
| 135 AbstractCompiler* CompileBroker::_compilers[2]; | |
| 136 | |
| 137 // These counters are used for assigning id's to each compilation | |
| 138 uint CompileBroker::_compilation_id = 0; | |
| 139 uint CompileBroker::_osr_compilation_id = 0; | |
| 140 | |
| 141 // Debugging information | |
| 142 int CompileBroker::_last_compile_type = no_compile; | |
| 143 int CompileBroker::_last_compile_level = CompLevel_none; | |
| 144 char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length]; | |
| 145 | |
| 146 // Performance counters | |
| 147 PerfCounter* CompileBroker::_perf_total_compilation = NULL; | |
| 148 PerfCounter* CompileBroker::_perf_osr_compilation = NULL; | |
| 149 PerfCounter* CompileBroker::_perf_standard_compilation = NULL; | |
| 150 | |
| 151 PerfCounter* CompileBroker::_perf_total_bailout_count = NULL; | |
| 152 PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL; | |
| 153 PerfCounter* CompileBroker::_perf_total_compile_count = NULL; | |
| 154 PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL; | |
| 155 PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL; | |
| 156 | |
| 157 PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL; | |
| 158 PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL; | |
| 159 PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL; | |
| 160 PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL; | |
| 161 | |
| 162 PerfStringVariable* CompileBroker::_perf_last_method = NULL; | |
| 163 PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL; | |
| 164 PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL; | |
| 165 PerfVariable* CompileBroker::_perf_last_compile_type = NULL; | |
| 166 PerfVariable* CompileBroker::_perf_last_compile_size = NULL; | |
| 167 PerfVariable* CompileBroker::_perf_last_failed_type = NULL; | |
| 168 PerfVariable* CompileBroker::_perf_last_invalidated_type = NULL; | |
| 169 | |
| 170 // Timers and counters for generating statistics | |
| 171 elapsedTimer CompileBroker::_t_total_compilation; | |
| 172 elapsedTimer CompileBroker::_t_osr_compilation; | |
| 173 elapsedTimer CompileBroker::_t_standard_compilation; | |
| 174 | |
| 175 int CompileBroker::_total_bailout_count = 0; | |
| 176 int CompileBroker::_total_invalidated_count = 0; | |
| 177 int CompileBroker::_total_compile_count = 0; | |
| 178 int CompileBroker::_total_osr_compile_count = 0; | |
| 179 int CompileBroker::_total_standard_compile_count = 0; | |
| 180 | |
| 181 int CompileBroker::_sum_osr_bytes_compiled = 0; | |
| 182 int CompileBroker::_sum_standard_bytes_compiled = 0; | |
| 183 int CompileBroker::_sum_nmethod_size = 0; | |
| 184 int CompileBroker::_sum_nmethod_code_size = 0; | |
| 185 | |
| 1783 | 186 CompileQueue* CompileBroker::_c2_method_queue = NULL; |
| 187 CompileQueue* CompileBroker::_c1_method_queue = NULL; | |
| 0 | 188 CompileTask* CompileBroker::_task_free_list = NULL; |
| 189 | |
| 190 GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL; | |
| 191 | |
| 192 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
193 class CompilationLog : public StringEventLog { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
194 public: |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
195 CompilationLog() : StringEventLog("Compilation events") { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
196 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
197 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
198 void log_compile(JavaThread* thread, CompileTask* task) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
199 StringLogMessage lm; |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
200 stringStream sstr = lm.stream(); |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
201 // msg.time_stamp().update_to(tty->time_stamp().ticks()); |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
202 task->print_compilation(&sstr, NULL, true); |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
203 log(thread, "%s", (const char*)lm); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
204 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
205 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
206 void log_nmethod(JavaThread* thread, nmethod* nm) { |
| 4944 | 207 log(thread, "nmethod %d%s " INTPTR_FORMAT " code ["INTPTR_FORMAT ", " INTPTR_FORMAT "]", |
| 208 nm->compile_id(), nm->is_osr_method() ? "%" : "", | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
209 nm, nm->code_begin(), nm->code_end()); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
210 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
211 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
212 void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
213 StringLogMessage lm; |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
214 lm.print("%4d COMPILE SKIPPED: %s", task->compile_id(), reason); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
215 if (retry_message != NULL) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
216 lm.append(" (%s)", retry_message); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
217 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
218 lm.print("\n"); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
219 log(thread, "%s", (const char*)lm); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
220 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
221 }; |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
222 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
223 static CompilationLog* _compilation_log = NULL; |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
224 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
225 void compileBroker_init() { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
226 if (LogEvents) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
227 _compilation_log = new CompilationLog(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
228 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
229 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
230 |
| 0 | 231 CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) { |
| 232 CompilerThread* thread = CompilerThread::current(); | |
| 233 thread->set_task(task); | |
| 234 CompileLog* log = thread->log(); | |
| 235 if (log != NULL) task->log_task_start(log); | |
| 236 } | |
| 237 | |
| 238 CompileTaskWrapper::~CompileTaskWrapper() { | |
| 239 CompilerThread* thread = CompilerThread::current(); | |
| 240 CompileTask* task = thread->task(); | |
| 241 CompileLog* log = thread->log(); | |
| 242 if (log != NULL) task->log_task_done(log); | |
| 243 thread->set_task(NULL); | |
| 244 task->set_code_handle(NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
245 thread->set_env(NULL); |
| 0 | 246 if (task->is_blocking()) { |
| 247 MutexLocker notifier(task->lock(), thread); | |
| 248 task->mark_complete(); | |
| 249 // Notify the waiting thread that the compilation has completed. | |
| 250 task->lock()->notify_all(); | |
| 251 } else { | |
| 252 task->mark_complete(); | |
| 253 | |
| 254 // By convention, the compiling thread is responsible for | |
| 255 // recycling a non-blocking CompileTask. | |
| 256 CompileBroker::free_task(task); | |
| 257 } | |
| 258 } | |
| 259 | |
| 260 | |
| 261 // ------------------------------------------------------------------ | |
| 262 // CompileTask::initialize | |
| 263 void CompileTask::initialize(int compile_id, | |
| 264 methodHandle method, | |
| 265 int osr_bci, | |
| 266 int comp_level, | |
| 267 methodHandle hot_method, | |
| 268 int hot_count, | |
| 269 const char* comment, | |
| 270 bool is_blocking) { | |
| 271 assert(!_lock->is_locked(), "bad locking"); | |
| 272 | |
| 273 _compile_id = compile_id; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
274 _method = method(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
275 _method_loader = JNIHandles::make_global(_method->method_holder()->class_loader()); |
| 0 | 276 _osr_bci = osr_bci; |
| 277 _is_blocking = is_blocking; | |
| 278 _comp_level = comp_level; | |
| 279 _num_inlined_bytecodes = 0; | |
| 280 | |
| 281 _is_complete = false; | |
| 282 _is_success = false; | |
| 283 _code_handle = NULL; | |
| 284 | |
| 285 _hot_method = NULL; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
286 _hot_method_loader = NULL; |
| 0 | 287 _hot_count = hot_count; |
| 288 _time_queued = 0; // tidy | |
| 289 _comment = comment; | |
| 290 | |
| 291 if (LogCompilation) { | |
| 292 _time_queued = os::elapsed_counter(); | |
| 293 if (hot_method.not_null()) { | |
| 294 if (hot_method == method) { | |
| 295 _hot_method = _method; | |
| 296 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
297 _hot_method = hot_method(); |
| 0 | 298 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
299 _hot_method_loader = JNIHandles::make_global(_hot_method->method_holder()->class_loader()); |
| 0 | 300 } |
| 301 } | |
| 302 | |
| 303 _next = NULL; | |
| 304 } | |
| 305 | |
| 306 // ------------------------------------------------------------------ | |
| 307 // CompileTask::code/set_code | |
| 308 nmethod* CompileTask::code() const { | |
| 309 if (_code_handle == NULL) return NULL; | |
| 310 return _code_handle->code(); | |
| 311 } | |
| 312 void CompileTask::set_code(nmethod* nm) { | |
| 313 if (_code_handle == NULL && nm == NULL) return; | |
| 314 guarantee(_code_handle != NULL, ""); | |
| 315 _code_handle->set_code(nm); | |
| 316 if (nm == NULL) _code_handle = NULL; // drop the handle also | |
| 317 } | |
| 318 | |
| 319 // ------------------------------------------------------------------ | |
| 320 // CompileTask::free | |
| 321 void CompileTask::free() { | |
| 322 set_code(NULL); | |
| 323 assert(!_lock->is_locked(), "Should not be locked when freed"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
324 JNIHandles::destroy_global(_method_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
325 JNIHandles::destroy_global(_hot_method_loader); |
| 0 | 326 } |
| 327 | |
| 328 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
329 void CompileTask::mark_on_stack() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
330 // Mark these methods as something redefine classes cannot remove. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
331 _method->set_on_stack(true); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
332 if (_hot_method != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
333 _hot_method->set_on_stack(true); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
334 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
335 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
336 |
| 0 | 337 // ------------------------------------------------------------------ |
| 338 // CompileTask::print | |
| 339 void CompileTask::print() { | |
| 340 tty->print("<CompileTask compile_id=%d ", _compile_id); | |
| 341 tty->print("method="); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
342 _method->print_name(tty); |
| 0 | 343 tty->print_cr(" osr_bci=%d is_blocking=%s is_complete=%s is_success=%s>", |
| 344 _osr_bci, bool_to_str(_is_blocking), | |
| 345 bool_to_str(_is_complete), bool_to_str(_is_success)); | |
| 346 } | |
| 347 | |
| 1783 | 348 |
| 0 | 349 // ------------------------------------------------------------------ |
| 350 // CompileTask::print_line_on_error | |
| 351 // | |
| 352 // This function is called by fatal error handler when the thread | |
| 353 // causing troubles is a compiler thread. | |
| 354 // | |
| 355 // Do not grab any lock, do not allocate memory. | |
| 356 // | |
| 357 // Otherwise it's the same as CompileTask::print_line() | |
| 358 // | |
| 359 void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) { | |
| 360 // print compiler name | |
| 361 st->print("%s:", CompileBroker::compiler(comp_level())->name()); | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
362 print_compilation(st); |
| 0 | 363 } |
| 364 | |
| 365 // ------------------------------------------------------------------ | |
| 366 // CompileTask::print_line | |
| 367 void CompileTask::print_line() { | |
| 368 ttyLocker ttyl; // keep the following output all in one block | |
| 369 // print compiler name if requested | |
| 370 if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler(comp_level())->name()); | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
371 print_compilation(); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
372 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
373 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
374 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
375 // ------------------------------------------------------------------ |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
376 // CompileTask::print_compilation_impl |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
377 void CompileTask::print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level, |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
378 bool is_osr_method, int osr_bci, bool is_blocking, |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
379 const char* msg, bool short_form) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
380 if (!short_form) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
381 st->print("%7d ", (int) st->time_stamp().milliseconds()); // print timestamp |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
382 } |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
383 st->print("%4d ", compile_id); // print compilation number |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
384 |
|
3752
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
385 // For unloaded methods the transition to zombie occurs after the |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
386 // method is cleared so it's impossible to report accurate |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
387 // information for that case. |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
388 bool is_synchronized = false; |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
389 bool has_exception_handler = false; |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
390 bool is_native = false; |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
391 if (method != NULL) { |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
392 is_synchronized = method->is_synchronized(); |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
393 has_exception_handler = method->has_exception_handler(); |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
394 is_native = method->is_native(); |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
395 } |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
396 // method attributes |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
397 const char compile_type = is_osr_method ? '%' : ' '; |
|
3752
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
398 const char sync_char = is_synchronized ? 's' : ' '; |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
399 const char exception_char = has_exception_handler ? '!' : ' '; |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
400 const char blocking_char = is_blocking ? 'b' : ' '; |
|
3752
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
401 const char native_char = is_native ? 'n' : ' '; |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
402 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
403 // print method attributes |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
404 st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, native_char); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
405 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
406 if (TieredCompilation) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
407 if (comp_level != -1) st->print("%d ", comp_level); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
408 else st->print("- "); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
409 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
410 st->print(" "); // more indent |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
411 |
|
3752
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
412 if (method == NULL) { |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
413 st->print("(method)"); |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
414 } else { |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
415 method->print_short_name(st); |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
416 if (is_osr_method) { |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
417 st->print(" @ %d", osr_bci); |
|
f918d6096e23
7050554: JSR 292 - need optimization for selectAlternative
never
parents:
3294
diff
changeset
|
418 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
419 if (method->is_native()) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
420 st->print(" (native)"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
421 else |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
422 st->print(" (%d bytes)", method->code_size()); |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
423 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
424 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
425 if (msg != NULL) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
426 st->print(" %s", msg); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
427 } |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
428 if (!short_form) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
429 st->cr(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
430 } |
| 0 | 431 } |
| 432 | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
433 // ------------------------------------------------------------------ |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
434 // CompileTask::print_inlining |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
435 void CompileTask::print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
436 // 1234567 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
437 st->print(" "); // print timestamp |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
438 // 1234 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
439 st->print(" "); // print compilation number |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
440 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
441 // method attributes |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
442 if (method->is_loaded()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
443 const char sync_char = method->is_synchronized() ? 's' : ' '; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
444 const char exception_char = method->has_exception_handlers() ? '!' : ' '; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
445 const char monitors_char = method->has_monitor_bytecodes() ? 'm' : ' '; |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
446 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
447 // print method attributes |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
448 st->print(" %c%c%c ", sync_char, exception_char, monitors_char); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
449 } else { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
450 // %s!bn |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
451 st->print(" "); // print method attributes |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
452 } |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
453 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
454 if (TieredCompilation) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
455 st->print(" "); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
456 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
457 st->print(" "); // more indent |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
458 st->print(" "); // initial inlining indent |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
459 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
460 for (int i = 0; i < inline_level; i++) st->print(" "); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
461 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
462 st->print("@ %d ", bci); // print bci |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
463 method->print_short_name(st); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
464 if (method->is_loaded()) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
465 st->print(" (%d bytes)", method->code_size()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
466 else |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
467 st->print(" (not loaded)"); |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
468 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
469 if (msg != NULL) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
470 st->print(" %s", msg); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
471 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
472 st->cr(); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
473 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
474 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
475 // ------------------------------------------------------------------ |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
476 // CompileTask::print_inline_indent |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
477 void CompileTask::print_inline_indent(int inline_level, outputStream* st) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
478 // 1234567 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
479 st->print(" "); // print timestamp |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
480 // 1234 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
481 st->print(" "); // print compilation number |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
482 // %s!bn |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
483 st->print(" "); // print method attributes |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
484 if (TieredCompilation) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
485 st->print(" "); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
486 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
487 st->print(" "); // more indent |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
488 st->print(" "); // initial inlining indent |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
489 for (int i = 0; i < inline_level; i++) st->print(" "); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
490 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
491 |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
492 // ------------------------------------------------------------------ |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
493 // CompileTask::print_compilation |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
494 void CompileTask::print_compilation(outputStream* st, const char* msg, bool short_form) { |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
495 bool is_osr_method = osr_bci() != InvocationEntryBci; |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
496 print_compilation_impl(st, method(), compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), msg, short_form); |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
497 } |
| 0 | 498 |
| 499 // ------------------------------------------------------------------ | |
| 500 // CompileTask::log_task | |
| 501 void CompileTask::log_task(xmlStream* log) { | |
| 502 Thread* thread = Thread::current(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
503 methodHandle method(thread, this->method()); |
| 0 | 504 ResourceMark rm(thread); |
| 505 | |
| 506 // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'> | |
| 507 if (_compile_id != 0) log->print(" compile_id='%d'", _compile_id); | |
| 508 if (_osr_bci != CompileBroker::standard_entry_bci) { | |
| 509 log->print(" compile_kind='osr'"); // same as nmethod::compile_kind | |
| 510 } // else compile_kind='c2c' | |
| 511 if (!method.is_null()) log->method(method); | |
| 512 if (_osr_bci != CompileBroker::standard_entry_bci) { | |
| 513 log->print(" osr_bci='%d'", _osr_bci); | |
| 514 } | |
| 515 if (_comp_level != CompLevel_highest_tier) { | |
| 516 log->print(" level='%d'", _comp_level); | |
| 517 } | |
| 518 if (_is_blocking) { | |
| 519 log->print(" blocking='1'"); | |
| 520 } | |
| 521 log->stamp(); | |
| 522 } | |
| 523 | |
| 524 | |
| 525 // ------------------------------------------------------------------ | |
| 526 // CompileTask::log_task_queued | |
| 527 void CompileTask::log_task_queued() { | |
| 528 Thread* thread = Thread::current(); | |
| 529 ttyLocker ttyl; | |
| 530 ResourceMark rm(thread); | |
| 531 | |
| 532 xtty->begin_elem("task_queued"); | |
| 533 log_task(xtty); | |
| 534 if (_comment != NULL) { | |
| 535 xtty->print(" comment='%s'", _comment); | |
| 536 } | |
| 537 if (_hot_method != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
538 methodHandle hot(thread, _hot_method); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
539 methodHandle method(thread, _method); |
| 0 | 540 if (hot() != method()) { |
| 541 xtty->method(hot); | |
| 542 } | |
| 543 } | |
| 544 if (_hot_count != 0) { | |
| 545 xtty->print(" hot_count='%d'", _hot_count); | |
| 546 } | |
| 547 xtty->end_elem(); | |
| 548 } | |
| 549 | |
| 550 | |
| 551 // ------------------------------------------------------------------ | |
| 552 // CompileTask::log_task_start | |
| 553 void CompileTask::log_task_start(CompileLog* log) { | |
| 554 log->begin_head("task"); | |
| 555 log_task(log); | |
| 556 log->end_head(); | |
| 557 } | |
| 558 | |
| 559 | |
| 560 // ------------------------------------------------------------------ | |
| 561 // CompileTask::log_task_done | |
| 562 void CompileTask::log_task_done(CompileLog* log) { | |
| 563 Thread* thread = Thread::current(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
564 methodHandle method(thread, this->method()); |
| 0 | 565 ResourceMark rm(thread); |
| 566 | |
| 567 // <task_done ... stamp='1.234'> </task> | |
| 568 nmethod* nm = code(); | |
| 569 log->begin_elem("task_done success='%d' nmsize='%d' count='%d'", | |
| 1748 | 570 _is_success, nm == NULL ? 0 : nm->content_size(), |
| 0 | 571 method->invocation_count()); |
| 572 int bec = method->backedge_count(); | |
| 573 if (bec != 0) log->print(" backedge_count='%d'", bec); | |
| 574 // Note: "_is_complete" is about to be set, but is not. | |
| 575 if (_num_inlined_bytecodes != 0) { | |
| 576 log->print(" inlined_bytes='%d'", _num_inlined_bytecodes); | |
| 577 } | |
| 578 log->stamp(); | |
| 579 log->end_elem(); | |
| 580 log->tail("task"); | |
| 581 log->clear_identities(); // next task will have different CI | |
| 582 if (log->unflushed_count() > 2000) { | |
| 583 log->flush(); | |
| 584 } | |
| 585 log->mark_file_end(); | |
| 586 } | |
| 587 | |
| 588 | |
| 589 | |
| 590 // ------------------------------------------------------------------ | |
| 591 // CompileQueue::add | |
| 592 // | |
| 593 // Add a CompileTask to a CompileQueue | |
| 594 void CompileQueue::add(CompileTask* task) { | |
| 595 assert(lock()->owned_by_self(), "must own lock"); | |
| 596 | |
| 597 task->set_next(NULL); | |
| 1783 | 598 task->set_prev(NULL); |
| 0 | 599 |
| 600 if (_last == NULL) { | |
| 601 // The compile queue is empty. | |
| 602 assert(_first == NULL, "queue is empty"); | |
| 603 _first = task; | |
| 604 _last = task; | |
| 605 } else { | |
| 606 // Append the task to the queue. | |
| 607 assert(_last->next() == NULL, "not last"); | |
| 608 _last->set_next(task); | |
| 1783 | 609 task->set_prev(_last); |
| 0 | 610 _last = task; |
| 611 } | |
| 1783 | 612 ++_size; |
| 0 | 613 |
| 614 // Mark the method as being in the compile queue. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
615 task->method()->set_queued_for_compilation(); |
| 0 | 616 |
| 617 if (CIPrintCompileQueue) { | |
| 618 print(); | |
| 619 } | |
| 620 | |
| 621 if (LogCompilation && xtty != NULL) { | |
| 622 task->log_task_queued(); | |
| 623 } | |
| 624 | |
| 625 // Notify CompilerThreads that a task is available. | |
| 1783 | 626 lock()->notify_all(); |
| 0 | 627 } |
| 628 | |
| 629 // ------------------------------------------------------------------ | |
| 630 // CompileQueue::get | |
| 631 // | |
| 632 // Get the next CompileTask from a CompileQueue | |
| 633 CompileTask* CompileQueue::get() { | |
|
1538
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
634 NMethodSweeper::possibly_sweep(); |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
635 |
| 0 | 636 MutexLocker locker(lock()); |
| 637 // Wait for an available CompileTask. | |
| 638 while (_first == NULL) { | |
| 639 // There is no work to be done right now. Wait. | |
|
1538
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
640 if (UseCodeCacheFlushing && (!CompileBroker::should_compile_new_jobs() || CodeCache::needs_flushing())) { |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
641 // During the emergency sweeping periods, wake up and sweep occasionally |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
642 bool timedout = lock()->wait(!Mutex::_no_safepoint_check_flag, NmethodSweepCheckInterval*1000); |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
643 if (timedout) { |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
644 MutexUnlocker ul(lock()); |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
645 // When otherwise not busy, run nmethod sweeping |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
646 NMethodSweeper::possibly_sweep(); |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
647 } |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
648 } else { |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
649 // During normal operation no need to wake up on timer |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
650 lock()->wait(); |
|
bfe29ec02863
6950075: nmethod sweeper should operate concurrently
never
parents:
1353
diff
changeset
|
651 } |
| 0 | 652 } |
| 1783 | 653 CompileTask* task = CompilationPolicy::policy()->select_task(this); |
| 654 remove(task); | |
| 655 return task; | |
| 656 } | |
| 0 | 657 |
| 1783 | 658 void CompileQueue::remove(CompileTask* task) |
| 659 { | |
| 660 assert(lock()->owned_by_self(), "must own lock"); | |
| 661 if (task->prev() != NULL) { | |
| 662 task->prev()->set_next(task->next()); | |
| 663 } else { | |
| 664 // max is the first element | |
| 665 assert(task == _first, "Sanity"); | |
| 666 _first = task->next(); | |
| 0 | 667 } |
| 668 | |
| 1783 | 669 if (task->next() != NULL) { |
| 670 task->next()->set_prev(task->prev()); | |
| 671 } else { | |
| 672 // max is the last element | |
| 673 assert(task == _last, "Sanity"); | |
| 674 _last = task->prev(); | |
| 675 } | |
| 676 --_size; | |
| 0 | 677 } |
| 678 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
679 // methods in the compile queue need to be marked as used on the stack |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
680 // so that they don't get reclaimed by Redefine Classes |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
681 void CompileQueue::mark_on_stack() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
682 CompileTask* task = _first; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
683 while (task != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
684 task->mark_on_stack(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
685 task = task->next(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
686 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
687 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
688 |
| 0 | 689 // ------------------------------------------------------------------ |
| 690 // CompileQueue::print | |
| 691 void CompileQueue::print() { | |
| 692 tty->print_cr("Contents of %s", name()); | |
| 693 tty->print_cr("----------------------"); | |
| 694 CompileTask* task = _first; | |
| 695 while (task != NULL) { | |
| 696 task->print_line(); | |
| 697 task = task->next(); | |
| 698 } | |
| 699 tty->print_cr("----------------------"); | |
| 700 } | |
| 701 | |
| 702 CompilerCounters::CompilerCounters(const char* thread_name, int instance, TRAPS) { | |
| 703 | |
| 704 _current_method[0] = '\0'; | |
| 705 _compile_type = CompileBroker::no_compile; | |
| 706 | |
| 707 if (UsePerfData) { | |
| 708 ResourceMark rm; | |
| 709 | |
| 710 // create the thread instance name space string - don't create an | |
| 711 // instance subspace if instance is -1 - keeps the adapterThread | |
| 712 // counters from having a ".0" namespace. | |
| 713 const char* thread_i = (instance == -1) ? thread_name : | |
| 714 PerfDataManager::name_space(thread_name, instance); | |
| 715 | |
| 716 | |
| 717 char* name = PerfDataManager::counter_name(thread_i, "method"); | |
| 718 _perf_current_method = | |
| 719 PerfDataManager::create_string_variable(SUN_CI, name, | |
| 720 cmname_buffer_length, | |
| 721 _current_method, CHECK); | |
| 722 | |
| 723 name = PerfDataManager::counter_name(thread_i, "type"); | |
| 724 _perf_compile_type = PerfDataManager::create_variable(SUN_CI, name, | |
| 725 PerfData::U_None, | |
| 726 (jlong)_compile_type, | |
| 727 CHECK); | |
| 728 | |
| 729 name = PerfDataManager::counter_name(thread_i, "time"); | |
| 730 _perf_time = PerfDataManager::create_counter(SUN_CI, name, | |
| 731 PerfData::U_Ticks, CHECK); | |
| 732 | |
| 733 name = PerfDataManager::counter_name(thread_i, "compiles"); | |
| 734 _perf_compiles = PerfDataManager::create_counter(SUN_CI, name, | |
| 735 PerfData::U_Events, CHECK); | |
| 736 } | |
| 737 } | |
| 738 | |
| 739 // ------------------------------------------------------------------ | |
| 740 // CompileBroker::compilation_init | |
| 741 // | |
| 742 // Initialize the Compilation object | |
| 743 void CompileBroker::compilation_init() { | |
| 744 _last_method_compiled[0] = '\0'; | |
| 745 | |
| 1970 | 746 #ifndef SHARK |
| 0 | 747 // Set the interface to the current compiler(s). |
| 1783 | 748 int c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple); |
| 749 int c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization); | |
| 0 | 750 #ifdef COMPILER1 |
| 1783 | 751 if (c1_count > 0) { |
| 752 _compilers[0] = new Compiler(); | |
| 753 } | |
| 0 | 754 #endif // COMPILER1 |
| 755 | |
| 756 #ifdef COMPILER2 | |
| 1783 | 757 if (c2_count > 0) { |
| 758 _compilers[1] = new C2Compiler(); | |
| 759 } | |
| 0 | 760 #endif // COMPILER2 |
| 761 | |
| 1970 | 762 #else // SHARK |
| 763 int c1_count = 0; | |
| 764 int c2_count = 1; | |
| 765 | |
| 766 _compilers[1] = new SharkCompiler(); | |
| 767 #endif // SHARK | |
| 1692 | 768 |
| 0 | 769 // Initialize the CompileTask free list |
| 770 _task_free_list = NULL; | |
| 771 | |
| 772 // Start the CompilerThreads | |
| 1783 | 773 init_compiler_threads(c1_count, c2_count); |
| 0 | 774 // totalTime performance counter is always created as it is required |
| 775 // by the implementation of java.lang.management.CompilationMBean. | |
| 776 { | |
| 777 EXCEPTION_MARK; | |
| 778 _perf_total_compilation = | |
| 779 PerfDataManager::create_counter(JAVA_CI, "totalTime", | |
| 780 PerfData::U_Ticks, CHECK); | |
| 781 } | |
| 782 | |
| 783 | |
| 784 if (UsePerfData) { | |
| 785 | |
| 786 EXCEPTION_MARK; | |
| 787 | |
| 788 // create the jvmstat performance counters | |
| 789 _perf_osr_compilation = | |
| 790 PerfDataManager::create_counter(SUN_CI, "osrTime", | |
| 791 PerfData::U_Ticks, CHECK); | |
| 792 | |
| 793 _perf_standard_compilation = | |
| 794 PerfDataManager::create_counter(SUN_CI, "standardTime", | |
| 795 PerfData::U_Ticks, CHECK); | |
| 796 | |
| 797 _perf_total_bailout_count = | |
| 798 PerfDataManager::create_counter(SUN_CI, "totalBailouts", | |
| 799 PerfData::U_Events, CHECK); | |
| 800 | |
| 801 _perf_total_invalidated_count = | |
| 802 PerfDataManager::create_counter(SUN_CI, "totalInvalidates", | |
| 803 PerfData::U_Events, CHECK); | |
| 804 | |
| 805 _perf_total_compile_count = | |
| 806 PerfDataManager::create_counter(SUN_CI, "totalCompiles", | |
| 807 PerfData::U_Events, CHECK); | |
| 808 _perf_total_osr_compile_count = | |
| 809 PerfDataManager::create_counter(SUN_CI, "osrCompiles", | |
| 810 PerfData::U_Events, CHECK); | |
| 811 | |
| 812 _perf_total_standard_compile_count = | |
| 813 PerfDataManager::create_counter(SUN_CI, "standardCompiles", | |
| 814 PerfData::U_Events, CHECK); | |
| 815 | |
| 816 _perf_sum_osr_bytes_compiled = | |
| 817 PerfDataManager::create_counter(SUN_CI, "osrBytes", | |
| 818 PerfData::U_Bytes, CHECK); | |
| 819 | |
| 820 _perf_sum_standard_bytes_compiled = | |
| 821 PerfDataManager::create_counter(SUN_CI, "standardBytes", | |
| 822 PerfData::U_Bytes, CHECK); | |
| 823 | |
| 824 _perf_sum_nmethod_size = | |
| 825 PerfDataManager::create_counter(SUN_CI, "nmethodSize", | |
| 826 PerfData::U_Bytes, CHECK); | |
| 827 | |
| 828 _perf_sum_nmethod_code_size = | |
| 829 PerfDataManager::create_counter(SUN_CI, "nmethodCodeSize", | |
| 830 PerfData::U_Bytes, CHECK); | |
| 831 | |
| 832 _perf_last_method = | |
| 833 PerfDataManager::create_string_variable(SUN_CI, "lastMethod", | |
| 834 CompilerCounters::cmname_buffer_length, | |
| 835 "", CHECK); | |
| 836 | |
| 837 _perf_last_failed_method = | |
| 838 PerfDataManager::create_string_variable(SUN_CI, "lastFailedMethod", | |
| 839 CompilerCounters::cmname_buffer_length, | |
| 840 "", CHECK); | |
| 841 | |
| 842 _perf_last_invalidated_method = | |
| 843 PerfDataManager::create_string_variable(SUN_CI, "lastInvalidatedMethod", | |
| 844 CompilerCounters::cmname_buffer_length, | |
| 845 "", CHECK); | |
| 846 | |
| 847 _perf_last_compile_type = | |
| 848 PerfDataManager::create_variable(SUN_CI, "lastType", | |
| 849 PerfData::U_None, | |
| 850 (jlong)CompileBroker::no_compile, | |
| 851 CHECK); | |
| 852 | |
| 853 _perf_last_compile_size = | |
| 854 PerfDataManager::create_variable(SUN_CI, "lastSize", | |
| 855 PerfData::U_Bytes, | |
| 856 (jlong)CompileBroker::no_compile, | |
| 857 CHECK); | |
| 858 | |
| 859 | |
| 860 _perf_last_failed_type = | |
| 861 PerfDataManager::create_variable(SUN_CI, "lastFailedType", | |
| 862 PerfData::U_None, | |
| 863 (jlong)CompileBroker::no_compile, | |
| 864 CHECK); | |
| 865 | |
| 866 _perf_last_invalidated_type = | |
| 867 PerfDataManager::create_variable(SUN_CI, "lastInvalidatedType", | |
| 868 PerfData::U_None, | |
| 869 (jlong)CompileBroker::no_compile, | |
| 870 CHECK); | |
| 871 } | |
| 872 | |
| 873 _initialized = true; | |
| 874 } | |
| 875 | |
| 876 | |
| 877 | |
| 878 // ------------------------------------------------------------------ | |
| 879 // CompileBroker::make_compiler_thread | |
| 880 CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) { | |
| 881 CompilerThread* compiler_thread = NULL; | |
| 882 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
883 Klass* k = |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
884 SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), |
| 0 | 885 true, CHECK_0); |
| 886 instanceKlassHandle klass (THREAD, k); | |
| 887 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_0); | |
| 888 Handle string = java_lang_String::create_from_str(name, CHECK_0); | |
| 889 | |
| 890 // Initialize thread_oop to put it into the system threadGroup | |
| 891 Handle thread_group (THREAD, Universe::system_thread_group()); | |
| 892 JavaValue result(T_VOID); | |
| 893 JavaCalls::call_special(&result, thread_oop, | |
| 894 klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
895 vmSymbols::object_initializer_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
896 vmSymbols::threadgroup_string_void_signature(), |
| 0 | 897 thread_group, |
| 898 string, | |
| 899 CHECK_0); | |
| 900 | |
| 901 { | |
| 902 MutexLocker mu(Threads_lock, THREAD); | |
| 903 compiler_thread = new CompilerThread(queue, counters); | |
| 904 // At this point the new CompilerThread data-races with this startup | |
| 905 // thread (which I believe is the primoridal thread and NOT the VM | |
| 906 // thread). This means Java bytecodes being executed at startup can | |
| 907 // queue compile jobs which will run at whatever default priority the | |
| 908 // newly created CompilerThread runs at. | |
| 909 | |
| 910 | |
| 911 // At this point it may be possible that no osthread was created for the | |
| 912 // JavaThread due to lack of memory. We would have to throw an exception | |
| 913 // in that case. However, since this must work and we do not allow | |
| 914 // exceptions anyway, check and abort if this fails. | |
| 915 | |
| 916 if (compiler_thread == NULL || compiler_thread->osthread() == NULL){ | |
| 917 vm_exit_during_initialization("java.lang.OutOfMemoryError", | |
| 918 "unable to create new native thread"); | |
| 919 } | |
| 920 | |
| 921 java_lang_Thread::set_thread(thread_oop(), compiler_thread); | |
| 922 | |
| 923 // Note that this only sets the JavaThread _priority field, which by | |
| 924 // definition is limited to Java priorities and not OS priorities. | |
| 925 // The os-priority is set in the CompilerThread startup code itself | |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
926 |
| 0 | 927 java_lang_Thread::set_priority(thread_oop(), NearMaxPriority); |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
928 |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
929 // Note that we cannot call os::set_priority because it expects Java |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
930 // priorities and we are *explicitly* using OS priorities so that it's |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
931 // possible to set the compiler thread priority higher than any Java |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
932 // thread. |
| 0 | 933 |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
934 int native_prio = CompilerThreadPriority; |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
935 if (native_prio == -1) { |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
936 if (UseCriticalCompilerThreadPriority) { |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
937 native_prio = os::java_to_os_priority[CriticalPriority]; |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
938 } else { |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
939 native_prio = os::java_to_os_priority[NearMaxPriority]; |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
940 } |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
941 } |
|
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
942 os::set_native_priority(compiler_thread, native_prio); |
| 0 | 943 |
| 944 java_lang_Thread::set_daemon(thread_oop()); | |
| 945 | |
| 946 compiler_thread->set_threadObj(thread_oop()); | |
| 947 Threads::add(compiler_thread); | |
| 948 Thread::start(compiler_thread); | |
| 949 } | |
|
4854
de268c8a8075
7082553: Interpret Thread.setPriority(Thread.MAX_PRIORITY) to mean FX60 on Solaris 10 and 11
phh
parents:
4122
diff
changeset
|
950 |
| 0 | 951 // Let go of Threads_lock before yielding |
| 952 os::yield(); // make sure that the compiler thread is started early (especially helpful on SOLARIS) | |
| 953 | |
| 954 return compiler_thread; | |
| 955 } | |
| 956 | |
| 957 | |
| 958 // ------------------------------------------------------------------ | |
| 959 // CompileBroker::init_compiler_threads | |
| 960 // | |
| 961 // Initialize the compilation queue | |
| 1783 | 962 void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) { |
| 0 | 963 EXCEPTION_MARK; |
| 2447 | 964 #if !defined(ZERO) && !defined(SHARK) |
| 1783 | 965 assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?"); |
| 2447 | 966 #endif // !ZERO && !SHARK |
| 1783 | 967 if (c2_compiler_count > 0) { |
| 968 _c2_method_queue = new CompileQueue("C2MethodQueue", MethodCompileQueue_lock); | |
| 969 } | |
| 970 if (c1_compiler_count > 0) { | |
| 971 _c1_method_queue = new CompileQueue("C1MethodQueue", MethodCompileQueue_lock); | |
| 972 } | |
| 0 | 973 |
| 1783 | 974 int compiler_count = c1_compiler_count + c2_compiler_count; |
| 975 | |
| 0 | 976 _method_threads = |
| 6197 | 977 new (ResourceObj::C_HEAP, mtCompiler) GrowableArray<CompilerThread*>(compiler_count, true); |
| 0 | 978 |
| 979 char name_buffer[256]; | |
| 1783 | 980 for (int i = 0; i < c2_compiler_count; i++) { |
| 0 | 981 // Create a name for our thread. |
| 1783 | 982 sprintf(name_buffer, "C2 CompilerThread%d", i); |
| 0 | 983 CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK); |
| 1783 | 984 CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, CHECK); |
| 0 | 985 _method_threads->append(new_thread); |
| 986 } | |
| 1783 | 987 |
| 988 for (int i = c2_compiler_count; i < compiler_count; i++) { | |
| 989 // Create a name for our thread. | |
| 990 sprintf(name_buffer, "C1 CompilerThread%d", i); | |
| 991 CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK); | |
| 992 CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, CHECK); | |
| 993 _method_threads->append(new_thread); | |
| 994 } | |
| 995 | |
| 0 | 996 if (UsePerfData) { |
| 997 PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes, | |
| 998 compiler_count, CHECK); | |
| 999 } | |
| 1000 } | |
| 1001 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1002 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1003 // Set the methods on the stack as on_stack so that redefine classes doesn't |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1004 // reclaim them |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1005 void CompileBroker::mark_on_stack() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1006 if (_c2_method_queue != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1007 _c2_method_queue->mark_on_stack(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1008 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1009 if (_c1_method_queue != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1010 _c1_method_queue->mark_on_stack(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1011 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1012 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1013 |
| 0 | 1014 // ------------------------------------------------------------------ |
| 1015 // CompileBroker::is_idle | |
| 1016 bool CompileBroker::is_idle() { | |
| 1783 | 1017 if (_c2_method_queue != NULL && !_c2_method_queue->is_empty()) { |
| 1018 return false; | |
| 1019 } else if (_c1_method_queue != NULL && !_c1_method_queue->is_empty()) { | |
| 0 | 1020 return false; |
| 1021 } else { | |
| 1022 int num_threads = _method_threads->length(); | |
| 1023 for (int i=0; i<num_threads; i++) { | |
| 1024 if (_method_threads->at(i)->task() != NULL) { | |
| 1025 return false; | |
| 1026 } | |
| 1027 } | |
| 1028 | |
| 1029 // No pending or active compilations. | |
| 1030 return true; | |
| 1031 } | |
| 1032 } | |
| 1033 | |
| 1034 | |
| 1035 // ------------------------------------------------------------------ | |
| 1036 // CompileBroker::compile_method | |
| 1037 // | |
| 1038 // Request compilation of a method. | |
| 1039 void CompileBroker::compile_method_base(methodHandle method, | |
| 1040 int osr_bci, | |
| 1041 int comp_level, | |
| 1042 methodHandle hot_method, | |
| 1043 int hot_count, | |
| 1044 const char* comment, | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4122
diff
changeset
|
1045 Thread* thread) { |
| 0 | 1046 // do nothing if compiler thread(s) is not available |
| 1047 if (!_initialized ) { | |
| 1048 return; | |
| 1049 } | |
| 1050 | |
| 1051 guarantee(!method->is_abstract(), "cannot compile abstract methods"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1052 assert(method->method_holder()->oop_is_instance(), |
| 0 | 1053 "sanity check"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1054 assert(!InstanceKlass::cast(method->method_holder())->is_not_initialized(), |
| 0 | 1055 "method holder must be initialized"); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1056 assert(!method->is_method_handle_intrinsic(), "do not enqueue these guys"); |
| 0 | 1057 |
| 1058 if (CIPrintRequests) { | |
| 1059 tty->print("request: "); | |
| 1060 method->print_short_name(tty); | |
| 1061 if (osr_bci != InvocationEntryBci) { | |
| 1062 tty->print(" osr_bci: %d", osr_bci); | |
| 1063 } | |
| 1064 tty->print(" comment: %s count: %d", comment, hot_count); | |
| 1065 if (!hot_method.is_null()) { | |
| 1066 tty->print(" hot: "); | |
| 1067 if (hot_method() != method()) { | |
| 1068 hot_method->print_short_name(tty); | |
| 1069 } else { | |
| 1070 tty->print("yes"); | |
| 1071 } | |
| 1072 } | |
| 1073 tty->cr(); | |
| 1074 } | |
| 1075 | |
| 1076 // A request has been made for compilation. Before we do any | |
| 1077 // real work, check to see if the method has been compiled | |
| 1078 // in the meantime with a definitive result. | |
| 1079 if (compilation_is_complete(method, osr_bci, comp_level)) { | |
| 1080 return; | |
| 1081 } | |
| 1082 | |
| 2403 | 1083 #ifndef PRODUCT |
| 1084 if (osr_bci != -1 && !FLAG_IS_DEFAULT(OSROnlyBCI)) { | |
| 1085 if ((OSROnlyBCI > 0) ? (OSROnlyBCI != osr_bci) : (-OSROnlyBCI == osr_bci)) { | |
| 1086 // Positive OSROnlyBCI means only compile that bci. Negative means don't compile that BCI. | |
| 1087 return; | |
| 1088 } | |
| 1089 } | |
| 1090 #endif | |
| 1783 | 1091 |
| 0 | 1092 // If this method is already in the compile queue, then |
| 1093 // we do not block the current thread. | |
| 1094 if (compilation_is_in_queue(method, osr_bci)) { | |
| 1095 // We may want to decay our counter a bit here to prevent | |
| 1096 // multiple denied requests for compilation. This is an | |
| 1097 // open compilation policy issue. Note: The other possibility, | |
| 1098 // in the case that this is a blocking compile request, is to have | |
| 1099 // all subsequent blocking requesters wait for completion of | |
| 1100 // ongoing compiles. Note that in this case we'll need a protocol | |
| 1101 // for freeing the associated compile tasks. [Or we could have | |
| 1102 // a single static monitor on which all these waiters sleep.] | |
| 1103 return; | |
| 1104 } | |
| 1105 | |
|
3294
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1106 // If the requesting thread is holding the pending list lock |
|
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1107 // then we just return. We can't risk blocking while holding |
|
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1108 // the pending list lock or a 3-way deadlock may occur |
|
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1109 // between the reference handler thread, a GC (instigated |
|
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1110 // by a compiler thread), and compiled method registration. |
|
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
1111 if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) { |
|
3294
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1112 return; |
|
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1113 } |
|
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1114 |
| 0 | 1115 // Outputs from the following MutexLocker block: |
| 1116 CompileTask* task = NULL; | |
| 1117 bool blocking = false; | |
| 1783 | 1118 CompileQueue* queue = compile_queue(comp_level); |
| 0 | 1119 |
| 1120 // Acquire our lock. | |
| 1121 { | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4122
diff
changeset
|
1122 MutexLocker locker(queue->lock(), thread); |
| 0 | 1123 |
| 1124 // Make sure the method has not slipped into the queues since | |
| 1125 // last we checked; note that those checks were "fast bail-outs". | |
| 1126 // Here we need to be more careful, see 14012000 below. | |
| 1127 if (compilation_is_in_queue(method, osr_bci)) { | |
| 1128 return; | |
| 1129 } | |
| 1130 | |
| 1131 // We need to check again to see if the compilation has | |
| 1132 // completed. A previous compilation may have registered | |
| 1133 // some result. | |
| 1134 if (compilation_is_complete(method, osr_bci, comp_level)) { | |
| 1135 return; | |
| 1136 } | |
| 1137 | |
| 1138 // We now know that this compilation is not pending, complete, | |
| 1139 // or prohibited. Assign a compile_id to this compilation | |
| 1140 // and check to see if it is in our [Start..Stop) range. | |
| 1141 uint compile_id = assign_compile_id(method, osr_bci); | |
| 1142 if (compile_id == 0) { | |
| 1143 // The compilation falls outside the allowed range. | |
| 1144 return; | |
| 1145 } | |
| 1146 | |
| 1147 // Should this thread wait for completion of the compile? | |
| 1148 blocking = is_compile_blocking(method, osr_bci); | |
| 1149 | |
| 1150 // We will enter the compilation in the queue. | |
| 1151 // 14012000: Note that this sets the queued_for_compile bits in | |
| 1152 // the target method. We can now reason that a method cannot be | |
| 1153 // queued for compilation more than once, as follows: | |
| 1154 // Before a thread queues a task for compilation, it first acquires | |
| 1155 // the compile queue lock, then checks if the method's queued bits | |
| 1156 // are set or it has already been compiled. Thus there can not be two | |
| 1157 // instances of a compilation task for the same method on the | |
| 1158 // compilation queue. Consider now the case where the compilation | |
| 1159 // thread has already removed a task for that method from the queue | |
| 1160 // and is in the midst of compiling it. In this case, the | |
| 1161 // queued_for_compile bits must be set in the method (and these | |
| 1162 // will be visible to the current thread, since the bits were set | |
| 1163 // under protection of the compile queue lock, which we hold now. | |
| 1164 // When the compilation completes, the compiler thread first sets | |
| 1165 // the compilation result and then clears the queued_for_compile | |
| 1166 // bits. Neither of these actions are protected by a barrier (or done | |
| 1167 // under the protection of a lock), so the only guarantee we have | |
| 1168 // (on machines with TSO (Total Store Order)) is that these values | |
| 1169 // will update in that order. As a result, the only combinations of | |
| 1170 // these bits that the current thread will see are, in temporal order: | |
| 1171 // <RESULT, QUEUE> : | |
| 1172 // <0, 1> : in compile queue, but not yet compiled | |
| 1173 // <1, 1> : compiled but queue bit not cleared | |
| 1174 // <1, 0> : compiled and queue bit cleared | |
| 1175 // Because we first check the queue bits then check the result bits, | |
| 1176 // we are assured that we cannot introduce a duplicate task. | |
| 1177 // Note that if we did the tests in the reverse order (i.e. check | |
| 1178 // result then check queued bit), we could get the result bit before | |
| 1179 // the compilation completed, and the queue bit after the compilation | |
| 1180 // completed, and end up introducing a "duplicate" (redundant) task. | |
| 1181 // In that case, the compiler thread should first check if a method | |
| 1182 // has already been compiled before trying to compile it. | |
| 1183 // NOTE: in the event that there are multiple compiler threads and | |
| 1184 // there is de-optimization/recompilation, things will get hairy, | |
| 1185 // and in that case it's best to protect both the testing (here) of | |
| 1186 // these bits, and their updating (here and elsewhere) under a | |
| 1187 // common lock. | |
| 1783 | 1188 task = create_compile_task(queue, |
| 0 | 1189 compile_id, method, |
| 1190 osr_bci, comp_level, | |
| 1191 hot_method, hot_count, comment, | |
| 1192 blocking); | |
| 1193 } | |
| 1194 | |
| 1195 if (blocking) { | |
| 1196 wait_for_completion(task); | |
| 1197 } | |
| 1198 } | |
| 1199 | |
| 1200 | |
| 1201 nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci, | |
| 1783 | 1202 int comp_level, |
| 0 | 1203 methodHandle hot_method, int hot_count, |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4122
diff
changeset
|
1204 const char* comment, Thread* THREAD) { |
| 0 | 1205 // make sure arguments make sense |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1206 assert(method->method_holder()->oop_is_instance(), "not an instance method"); |
| 0 | 1207 assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range"); |
| 1208 assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1209 assert(!InstanceKlass::cast(method->method_holder())->is_not_initialized(), "method holder must be initialized"); |
| 0 | 1210 |
| 1783 | 1211 if (!TieredCompilation) { |
| 1212 comp_level = CompLevel_highest_tier; | |
| 0 | 1213 } |
| 1214 | |
| 1215 // return quickly if possible | |
| 1216 | |
| 1217 // lock, make sure that the compilation | |
| 1218 // isn't prohibited in a straightforward way. | |
| 1219 | |
| 1220 if (compiler(comp_level) == NULL || compilation_is_prohibited(method, osr_bci, comp_level)) { | |
| 1221 return NULL; | |
| 1222 } | |
| 1223 | |
| 1224 if (osr_bci == InvocationEntryBci) { | |
| 1225 // standard compilation | |
| 1226 nmethod* method_code = method->code(); | |
| 1783 | 1227 if (method_code != NULL) { |
| 1228 if (compilation_is_complete(method, osr_bci, comp_level)) { | |
| 1229 return method_code; | |
| 1230 } | |
| 0 | 1231 } |
| 1232 if (method->is_not_compilable(comp_level)) return NULL; | |
| 1202 | 1233 |
|
1300
428a9c451986
6935466: new CodeCache flushing code is not guarded by the flag
kvn
parents:
1208
diff
changeset
|
1234 if (UseCodeCacheFlushing) { |
|
428a9c451986
6935466: new CodeCache flushing code is not guarded by the flag
kvn
parents:
1208
diff
changeset
|
1235 nmethod* saved = CodeCache::find_and_remove_saved_code(method()); |
|
428a9c451986
6935466: new CodeCache flushing code is not guarded by the flag
kvn
parents:
1208
diff
changeset
|
1236 if (saved != NULL) { |
|
428a9c451986
6935466: new CodeCache flushing code is not guarded by the flag
kvn
parents:
1208
diff
changeset
|
1237 method->set_code(method, saved); |
|
428a9c451986
6935466: new CodeCache flushing code is not guarded by the flag
kvn
parents:
1208
diff
changeset
|
1238 return saved; |
|
428a9c451986
6935466: new CodeCache flushing code is not guarded by the flag
kvn
parents:
1208
diff
changeset
|
1239 } |
| 1202 | 1240 } |
| 1241 | |
| 0 | 1242 } else { |
| 1243 // osr compilation | |
| 1244 #ifndef TIERED | |
| 1245 // seems like an assert of dubious value | |
| 1783 | 1246 assert(comp_level == CompLevel_highest_tier, |
| 0 | 1247 "all OSR compiles are assumed to be at a single compilation lavel"); |
| 1248 #endif // TIERED | |
| 1783 | 1249 // We accept a higher level osr method |
| 1250 nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false); | |
| 0 | 1251 if (nm != NULL) return nm; |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1252 if (method->is_not_osr_compilable(comp_level)) return NULL; |
| 0 | 1253 } |
| 1254 | |
| 1255 assert(!HAS_PENDING_EXCEPTION, "No exception should be present"); | |
| 1256 // some prerequisites that are compiler specific | |
| 2447 | 1257 if (compiler(comp_level)->is_c2() || compiler(comp_level)->is_shark()) { |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4122
diff
changeset
|
1258 method->constants()->resolve_string_constants(CHECK_AND_CLEAR_NULL); |
| 0 | 1259 // Resolve all classes seen in the signature of the method |
| 1260 // we are compiling. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1261 Method::load_signature_classes(method, CHECK_AND_CLEAR_NULL); |
| 0 | 1262 } |
| 1263 | |
| 1264 // If the method is native, do the lookup in the thread requesting | |
| 1265 // the compilation. Native lookups can load code, which is not | |
| 1266 // permitted during compilation. | |
| 1267 // | |
| 1268 // Note: A native method implies non-osr compilation which is | |
| 1269 // checked with an assertion at the entry of this method. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1270 if (method->is_native() && !method->is_method_handle_intrinsic()) { |
| 0 | 1271 bool in_base_library; |
| 1272 address adr = NativeLookup::lookup(method, in_base_library, THREAD); | |
| 1273 if (HAS_PENDING_EXCEPTION) { | |
| 1274 // In case of an exception looking up the method, we just forget | |
| 1275 // about it. The interpreter will kick-in and throw the exception. | |
| 1276 method->set_not_compilable(); // implies is_not_osr_compilable() | |
| 1277 CLEAR_PENDING_EXCEPTION; | |
| 1278 return NULL; | |
| 1279 } | |
| 1280 assert(method->has_native_function(), "must have native code by now"); | |
| 1281 } | |
| 1282 | |
| 1283 // RedefineClasses() has replaced this method; just return | |
| 1284 if (method->is_old()) { | |
| 1285 return NULL; | |
| 1286 } | |
| 1287 | |
| 1288 // JVMTI -- post_compile_event requires jmethod_id() that may require | |
| 1289 // a lock the compiling thread can not acquire. Prefetch it here. | |
| 1290 if (JvmtiExport::should_post_compiled_method_load()) { | |
| 1291 method->jmethod_id(); | |
| 1292 } | |
| 1293 | |
| 1202 | 1294 // If the compiler is shut off due to code cache flushing or otherwise, |
| 1295 // fail out now so blocking compiles dont hang the java thread | |
| 1296 if (!should_compile_new_jobs() || (UseCodeCacheFlushing && CodeCache::needs_flushing())) { | |
| 1783 | 1297 CompilationPolicy::policy()->delay_compilation(method()); |
| 1202 | 1298 return NULL; |
| 1299 } | |
| 1300 | |
| 0 | 1301 // do the compilation |
| 1302 if (method->is_native()) { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
1303 if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) { |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1304 // Acquire our lock. |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1305 int compile_id; |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1306 { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1307 MutexLocker locker(MethodCompileQueue_lock, THREAD); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1308 compile_id = assign_compile_id(method, standard_entry_bci); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1309 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2403
diff
changeset
|
1310 (void) AdapterHandlerLibrary::create_native_wrapper(method, compile_id); |
| 0 | 1311 } else { |
| 1312 return NULL; | |
| 1313 } | |
| 1314 } else { | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4122
diff
changeset
|
1315 compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, THREAD); |
| 0 | 1316 } |
| 1317 | |
| 1318 // return requested nmethod | |
| 1783 | 1319 // We accept a higher level osr method |
| 1320 return osr_bci == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci, comp_level, false); | |
| 0 | 1321 } |
| 1322 | |
| 1323 | |
| 1324 // ------------------------------------------------------------------ | |
| 1325 // CompileBroker::compilation_is_complete | |
| 1326 // | |
| 1327 // See if compilation of this method is already complete. | |
| 1328 bool CompileBroker::compilation_is_complete(methodHandle method, | |
| 1329 int osr_bci, | |
| 1330 int comp_level) { | |
| 1331 bool is_osr = (osr_bci != standard_entry_bci); | |
| 1332 if (is_osr) { | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1333 if (method->is_not_osr_compilable(comp_level)) { |
| 0 | 1334 return true; |
| 1335 } else { | |
| 1783 | 1336 nmethod* result = method->lookup_osr_nmethod_for(osr_bci, comp_level, true); |
| 0 | 1337 return (result != NULL); |
| 1338 } | |
| 1339 } else { | |
| 1340 if (method->is_not_compilable(comp_level)) { | |
| 1341 return true; | |
| 1342 } else { | |
| 1343 nmethod* result = method->code(); | |
| 1344 if (result == NULL) return false; | |
| 1783 | 1345 return comp_level == result->comp_level(); |
| 0 | 1346 } |
| 1347 } | |
| 1348 } | |
| 1349 | |
| 1350 | |
| 1351 // ------------------------------------------------------------------ | |
| 1352 // CompileBroker::compilation_is_in_queue | |
| 1353 // | |
| 1354 // See if this compilation is already requested. | |
| 1355 // | |
| 1356 // Implementation note: there is only a single "is in queue" bit | |
| 1357 // for each method. This means that the check below is overly | |
| 1358 // conservative in the sense that an osr compilation in the queue | |
| 1359 // will block a normal compilation from entering the queue (and vice | |
| 1360 // versa). This can be remedied by a full queue search to disambiguate | |
| 1361 // cases. If it is deemed profitible, this may be done. | |
| 1362 bool CompileBroker::compilation_is_in_queue(methodHandle method, | |
| 1783 | 1363 int osr_bci) { |
| 0 | 1364 return method->queued_for_compilation(); |
| 1365 } | |
| 1366 | |
| 1367 // ------------------------------------------------------------------ | |
| 1368 // CompileBroker::compilation_is_prohibited | |
| 1369 // | |
| 1370 // See if this compilation is not allowed. | |
| 1371 bool CompileBroker::compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level) { | |
| 1372 bool is_native = method->is_native(); | |
| 1373 // Some compilers may not support the compilation of natives. | |
| 1374 if (is_native && | |
| 1375 (!CICompileNatives || !compiler(comp_level)->supports_native())) { | |
| 1783 | 1376 method->set_not_compilable_quietly(comp_level); |
| 0 | 1377 return true; |
| 1378 } | |
| 1379 | |
| 1380 bool is_osr = (osr_bci != standard_entry_bci); | |
| 1381 // Some compilers may not support on stack replacement. | |
| 1382 if (is_osr && | |
| 1383 (!CICompileOSR || !compiler(comp_level)->supports_osr())) { | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1384 method->set_not_osr_compilable(comp_level); |
| 0 | 1385 return true; |
| 1386 } | |
| 1387 | |
| 1388 // The method may be explicitly excluded by the user. | |
| 1389 bool quietly; | |
| 1390 if (CompilerOracle::should_exclude(method, quietly)) { | |
| 1391 if (!quietly) { | |
| 1392 // This does not happen quietly... | |
| 1393 ResourceMark rm; | |
| 1394 tty->print("### Excluding %s:%s", | |
| 1395 method->is_native() ? "generation of native wrapper" : "compile", | |
| 1396 (method->is_static() ? " static" : "")); | |
| 1397 method->print_short_name(tty); | |
| 1398 tty->cr(); | |
| 1399 } | |
|
1208
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1202
diff
changeset
|
1400 method->set_not_compilable_quietly(); |
| 0 | 1401 } |
| 1402 | |
| 1403 return false; | |
| 1404 } | |
| 1405 | |
| 1406 | |
| 1407 // ------------------------------------------------------------------ | |
| 1408 // CompileBroker::assign_compile_id | |
| 1409 // | |
| 1410 // Assign a serialized id number to this compilation request. If the | |
| 1411 // number falls out of the allowed range, return a 0. OSR | |
| 1412 // compilations may be numbered separately from regular compilations | |
| 1413 // if certain debugging flags are used. | |
| 1414 uint CompileBroker::assign_compile_id(methodHandle method, int osr_bci) { | |
| 1783 | 1415 assert(MethodCompileQueue_lock->owner() == Thread::current(), |
| 0 | 1416 "must hold the compilation queue lock"); |
| 1417 bool is_osr = (osr_bci != standard_entry_bci); | |
| 1418 uint id; | |
| 1419 if (CICountOSR && is_osr) { | |
| 1420 id = ++_osr_compilation_id; | |
| 1421 if ((uint)CIStartOSR <= id && id < (uint)CIStopOSR) { | |
| 1422 return id; | |
| 1423 } | |
| 1424 } else { | |
| 1425 id = ++_compilation_id; | |
| 1426 if ((uint)CIStart <= id && id < (uint)CIStop) { | |
| 1427 return id; | |
| 1428 } | |
| 1429 } | |
| 1430 | |
| 1431 // Method was not in the appropriate compilation range. | |
|
1208
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1202
diff
changeset
|
1432 method->set_not_compilable_quietly(); |
| 0 | 1433 return 0; |
| 1434 } | |
| 1435 | |
| 1436 | |
| 1437 // ------------------------------------------------------------------ | |
| 1438 // CompileBroker::is_compile_blocking | |
| 1439 // | |
| 1440 // Should the current thread be blocked until this compilation request | |
| 1441 // has been fulfilled? | |
| 1442 bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) { | |
|
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
1443 assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock"); |
|
3294
86ebb26bcdeb
7037756: Deadlock in compiler thread similiar to 6789220
johnc
parents:
2482
diff
changeset
|
1444 return !BackgroundCompilation; |
| 0 | 1445 } |
| 1446 | |
| 1447 | |
| 1448 // ------------------------------------------------------------------ | |
| 1449 // CompileBroker::preload_classes | |
| 1450 void CompileBroker::preload_classes(methodHandle method, TRAPS) { | |
| 1451 // Move this code over from c1_Compiler.cpp | |
| 1452 ShouldNotReachHere(); | |
| 1453 } | |
| 1454 | |
| 1455 | |
| 1456 // ------------------------------------------------------------------ | |
| 1457 // CompileBroker::create_compile_task | |
| 1458 // | |
| 1459 // Create a CompileTask object representing the current request for | |
| 1460 // compilation. Add this task to the queue. | |
| 1461 CompileTask* CompileBroker::create_compile_task(CompileQueue* queue, | |
| 1462 int compile_id, | |
| 1463 methodHandle method, | |
| 1464 int osr_bci, | |
| 1465 int comp_level, | |
| 1466 methodHandle hot_method, | |
| 1467 int hot_count, | |
| 1468 const char* comment, | |
| 1469 bool blocking) { | |
| 1470 CompileTask* new_task = allocate_task(); | |
| 1471 new_task->initialize(compile_id, method, osr_bci, comp_level, | |
| 1472 hot_method, hot_count, comment, | |
| 1473 blocking); | |
| 1474 queue->add(new_task); | |
| 1475 return new_task; | |
| 1476 } | |
| 1477 | |
| 1478 | |
| 1479 // ------------------------------------------------------------------ | |
| 1480 // CompileBroker::allocate_task | |
| 1481 // | |
| 1482 // Allocate a CompileTask, from the free list if possible. | |
| 1483 CompileTask* CompileBroker::allocate_task() { | |
| 1484 MutexLocker locker(CompileTaskAlloc_lock); | |
| 1485 CompileTask* task = NULL; | |
| 1486 if (_task_free_list != NULL) { | |
| 1487 task = _task_free_list; | |
| 1488 _task_free_list = task->next(); | |
| 1489 task->set_next(NULL); | |
| 1490 } else { | |
| 1491 task = new CompileTask(); | |
| 1492 task->set_next(NULL); | |
| 1493 } | |
| 1494 return task; | |
| 1495 } | |
| 1496 | |
| 1497 | |
| 1498 // ------------------------------------------------------------------ | |
| 1499 // CompileBroker::free_task | |
| 1500 // | |
| 1501 // Add a task to the free list. | |
| 1502 void CompileBroker::free_task(CompileTask* task) { | |
| 1503 MutexLocker locker(CompileTaskAlloc_lock); | |
| 1504 task->free(); | |
| 1505 task->set_next(_task_free_list); | |
| 1506 _task_free_list = task; | |
| 1507 } | |
| 1508 | |
| 1509 | |
| 1510 // ------------------------------------------------------------------ | |
| 1511 // CompileBroker::wait_for_completion | |
| 1512 // | |
| 1513 // Wait for the given method CompileTask to complete. | |
| 1514 void CompileBroker::wait_for_completion(CompileTask* task) { | |
| 1515 if (CIPrintCompileQueue) { | |
| 1516 tty->print_cr("BLOCKING FOR COMPILE"); | |
| 1517 } | |
| 1518 | |
| 1519 assert(task->is_blocking(), "can only wait on blocking task"); | |
| 1520 | |
| 1521 JavaThread *thread = JavaThread::current(); | |
| 1522 thread->set_blocked_on_compilation(true); | |
| 1523 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1524 methodHandle method(thread, task->method()); |
| 0 | 1525 { |
| 1526 MutexLocker waiter(task->lock(), thread); | |
| 1527 | |
| 1528 while (!task->is_complete()) | |
| 1529 task->lock()->wait(); | |
| 1530 } | |
| 1531 // It is harmless to check this status without the lock, because | |
| 1532 // completion is a stable property (until the task object is recycled). | |
| 1533 assert(task->is_complete(), "Compilation should have completed"); | |
| 1534 assert(task->code_handle() == NULL, "must be reset"); | |
| 1535 | |
| 1536 thread->set_blocked_on_compilation(false); | |
| 1537 | |
| 1538 // By convention, the waiter is responsible for recycling a | |
| 1539 // blocking CompileTask. Since there is only one waiter ever | |
| 1540 // waiting on a CompileTask, we know that no one else will | |
| 1541 // be using this CompileTask; we can free it. | |
| 1542 free_task(task); | |
| 1543 } | |
| 1544 | |
| 1545 // ------------------------------------------------------------------ | |
| 1546 // CompileBroker::compiler_thread_loop | |
| 1547 // | |
| 1548 // The main loop run by a CompilerThread. | |
| 1549 void CompileBroker::compiler_thread_loop() { | |
| 1550 CompilerThread* thread = CompilerThread::current(); | |
| 1551 CompileQueue* queue = thread->queue(); | |
| 1552 | |
| 1553 // For the thread that initializes the ciObjectFactory | |
| 1554 // this resource mark holds all the shared objects | |
| 1555 ResourceMark rm; | |
| 1556 | |
| 1557 // First thread to get here will initialize the compiler interface | |
| 1558 | |
| 1559 if (!ciObjectFactory::is_initialized()) { | |
| 1560 ASSERT_IN_VM; | |
| 1561 MutexLocker only_one (CompileThread_lock, thread); | |
| 1562 if (!ciObjectFactory::is_initialized()) { | |
| 1563 ciObjectFactory::initialize(); | |
| 1564 } | |
| 1565 } | |
| 1566 | |
| 1567 // Open a log. | |
| 1568 if (LogCompilation) { | |
| 1569 init_compiler_thread_log(); | |
| 1570 } | |
| 1571 CompileLog* log = thread->log(); | |
| 1572 if (log != NULL) { | |
| 1573 log->begin_elem("start_compile_thread thread='" UINTX_FORMAT "' process='%d'", | |
| 1574 os::current_thread_id(), | |
| 1575 os::current_process_id()); | |
| 1576 log->stamp(); | |
| 1577 log->end_elem(); | |
| 1578 } | |
| 1579 | |
| 1580 while (true) { | |
| 1581 { | |
| 1582 // We need this HandleMark to avoid leaking VM handles. | |
| 1583 HandleMark hm(thread); | |
| 1202 | 1584 |
|
2353
1c0cf339481b
7025742: Can not use CodeCache::unallocated_capacity() with fragmented CodeCache
kvn
parents:
2260
diff
changeset
|
1585 if (CodeCache::largest_free_block() < CodeCacheMinimumFreeSpace) { |
| 1202 | 1586 // the code cache is really full |
| 1587 handle_full_code_cache(); | |
| 1588 } else if (UseCodeCacheFlushing && CodeCache::needs_flushing()) { | |
| 1589 // Attempt to start cleaning the code cache while there is still a little headroom | |
| 1590 NMethodSweeper::handle_full_code_cache(false); | |
| 0 | 1591 } |
| 1592 | |
| 1593 CompileTask* task = queue->get(); | |
| 1594 | |
| 1595 // Give compiler threads an extra quanta. They tend to be bursty and | |
| 1596 // this helps the compiler to finish up the job. | |
| 1597 if( CompilerThreadHintNoPreempt ) | |
| 1598 os::hint_no_preempt(); | |
| 1599 | |
| 1600 // trace per thread time and compile statistics | |
| 1601 CompilerCounters* counters = ((CompilerThread*)thread)->counters(); | |
| 1602 PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter()); | |
| 1603 | |
| 1604 // Assign the task to the current thread. Mark this compilation | |
| 1605 // thread as active for the profiler. | |
| 1606 CompileTaskWrapper ctw(task); | |
| 1607 nmethodLocker result_handle; // (handle for the nmethod produced by this task) | |
| 1608 task->set_code_handle(&result_handle); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1609 methodHandle method(thread, task->method()); |
| 0 | 1610 |
| 1611 // Never compile a method if breakpoints are present in it | |
| 1612 if (method()->number_of_breakpoints() == 0) { | |
| 1613 // Compile the method. | |
| 1202 | 1614 if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) { |
| 0 | 1615 #ifdef COMPILER1 |
| 1616 // Allow repeating compilations for the purpose of benchmarking | |
| 1617 // compile speed. This is not useful for customers. | |
| 1618 if (CompilationRepeat != 0) { | |
| 1619 int compile_count = CompilationRepeat; | |
| 1620 while (compile_count > 0) { | |
| 1621 invoke_compiler_on_method(task); | |
| 1622 nmethod* nm = method->code(); | |
| 1623 if (nm != NULL) { | |
| 1624 nm->make_zombie(); | |
| 1625 method->clear_code(); | |
| 1626 } | |
| 1627 compile_count--; | |
| 1628 } | |
| 1629 } | |
| 1630 #endif /* COMPILER1 */ | |
| 1631 invoke_compiler_on_method(task); | |
| 1632 } else { | |
| 1633 // After compilation is disabled, remove remaining methods from queue | |
| 1634 method->clear_queued_for_compilation(); | |
| 1635 } | |
| 1636 } | |
| 1637 } | |
| 1638 } | |
| 1639 } | |
| 1640 | |
| 1641 | |
| 1642 // ------------------------------------------------------------------ | |
| 1643 // CompileBroker::init_compiler_thread_log | |
| 1644 // | |
| 1645 // Set up state required by +LogCompilation. | |
| 1646 void CompileBroker::init_compiler_thread_log() { | |
| 1647 CompilerThread* thread = CompilerThread::current(); | |
| 1648 char fileBuf[4*K]; | |
| 1649 FILE* fp = NULL; | |
| 1650 char* file = NULL; | |
| 1651 intx thread_id = os::current_thread_id(); | |
| 1652 for (int try_temp_dir = 1; try_temp_dir >= 0; try_temp_dir--) { | |
| 1653 const char* dir = (try_temp_dir ? os::get_temp_directory() : NULL); | |
|
1353
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1654 if (dir == NULL) { |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1655 jio_snprintf(fileBuf, sizeof(fileBuf), "hs_c" UINTX_FORMAT "_pid%u.log", |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1656 thread_id, os::current_process_id()); |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1657 } else { |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1658 jio_snprintf(fileBuf, sizeof(fileBuf), |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1659 "%s%shs_c" UINTX_FORMAT "_pid%u.log", dir, |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1660 os::file_separator(), thread_id, os::current_process_id()); |
|
a2ea687fdc7c
6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents:
1300
diff
changeset
|
1661 } |
| 0 | 1662 fp = fopen(fileBuf, "at"); |
| 1663 if (fp != NULL) { | |
| 6197 | 1664 file = NEW_C_HEAP_ARRAY(char, strlen(fileBuf)+1, mtCompiler); |
| 0 | 1665 strcpy(file, fileBuf); |
| 1666 break; | |
| 1667 } | |
| 1668 } | |
| 1669 if (fp == NULL) { | |
| 1670 warning("Cannot open log file: %s", fileBuf); | |
| 1671 } else { | |
| 1672 if (LogCompilation && Verbose) | |
| 1673 tty->print_cr("Opening compilation log %s", file); | |
| 6197 | 1674 CompileLog* log = new(ResourceObj::C_HEAP, mtCompiler) CompileLog(file, fp, thread_id); |
| 0 | 1675 thread->init_log(log); |
| 1676 | |
| 1677 if (xtty != NULL) { | |
| 1678 ttyLocker ttyl; | |
| 1679 | |
| 1680 // Record any per thread log files | |
| 1681 xtty->elem("thread_logfile thread='%d' filename='%s'", thread_id, file); | |
| 1682 } | |
| 1683 } | |
| 1684 } | |
| 1685 | |
| 1686 // ------------------------------------------------------------------ | |
| 1687 // CompileBroker::set_should_block | |
| 1688 // | |
| 1689 // Set _should_block. | |
| 1690 // Call this from the VM, with Threads_lock held and a safepoint requested. | |
| 1691 void CompileBroker::set_should_block() { | |
| 1692 assert(Threads_lock->owner() == Thread::current(), "must have threads lock"); | |
| 1693 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint already"); | |
| 1694 #ifndef PRODUCT | |
| 1695 if (PrintCompilation && (Verbose || WizardMode)) | |
| 1696 tty->print_cr("notifying compiler thread pool to block"); | |
| 1697 #endif | |
| 1698 _should_block = true; | |
| 1699 } | |
| 1700 | |
| 1701 // ------------------------------------------------------------------ | |
| 1702 // CompileBroker::maybe_block | |
| 1703 // | |
| 1704 // Call this from the compiler at convenient points, to poll for _should_block. | |
| 1705 void CompileBroker::maybe_block() { | |
| 1706 if (_should_block) { | |
| 1707 #ifndef PRODUCT | |
| 1708 if (PrintCompilation && (Verbose || WizardMode)) | |
| 1709 tty->print_cr("compiler thread " INTPTR_FORMAT " poll detects block request", Thread::current()); | |
| 1710 #endif | |
| 1711 ThreadInVMfromNative tivfn(JavaThread::current()); | |
| 1712 } | |
| 1713 } | |
| 1714 | |
| 1715 // ------------------------------------------------------------------ | |
| 1716 // CompileBroker::invoke_compiler_on_method | |
| 1717 // | |
| 1718 // Compile a method. | |
| 1719 // | |
| 1720 void CompileBroker::invoke_compiler_on_method(CompileTask* task) { | |
| 1721 if (PrintCompilation) { | |
| 1722 ResourceMark rm; | |
| 1723 task->print_line(); | |
| 1724 } | |
| 1725 elapsedTimer time; | |
| 1726 | |
| 1727 CompilerThread* thread = CompilerThread::current(); | |
| 1728 ResourceMark rm(thread); | |
| 1729 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1730 if (LogEvents) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1731 _compilation_log->log_compile(thread, task); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1732 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1733 |
| 0 | 1734 // Common flags. |
| 1735 uint compile_id = task->compile_id(); | |
| 1736 int osr_bci = task->osr_bci(); | |
| 1737 bool is_osr = (osr_bci != standard_entry_bci); | |
| 1738 bool should_log = (thread->log() != NULL); | |
| 1739 bool should_break = false; | |
| 1740 { | |
| 1741 // create the handle inside it's own block so it can't | |
| 1742 // accidentally be referenced once the thread transitions to | |
| 1743 // native. The NoHandleMark before the transition should catch | |
| 1744 // any cases where this occurs in the future. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1745 methodHandle method(thread, task->method()); |
| 0 | 1746 should_break = check_break_at(method, compile_id, is_osr); |
| 1747 if (should_log && !CompilerOracle::should_log(method)) { | |
| 1748 should_log = false; | |
| 1749 } | |
| 1750 assert(!method->is_native(), "no longer compile natives"); | |
| 1751 | |
| 1752 // Save information about this method in case of failure. | |
| 1753 set_last_compile(thread, method, is_osr, task->comp_level()); | |
| 1754 | |
| 1755 DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler(task->comp_level()), method); | |
| 1756 } | |
| 1757 | |
| 1758 // Allocate a new set of JNI handles. | |
| 1759 push_jni_handle_block(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1760 Method* target_handle = task->method(); |
| 0 | 1761 int compilable = ciEnv::MethodCompilable; |
| 1762 { | |
| 1763 int system_dictionary_modification_counter; | |
| 1764 { | |
| 1765 MutexLocker locker(Compile_lock, thread); | |
| 1766 system_dictionary_modification_counter = SystemDictionary::number_of_modifications(); | |
| 1767 } | |
| 1768 | |
| 1769 NoHandleMark nhm; | |
| 1770 ThreadToNativeFromVM ttn(thread); | |
| 1771 | |
| 1772 ciEnv ci_env(task, system_dictionary_modification_counter); | |
| 1773 if (should_break) { | |
| 1774 ci_env.set_break_at_compile(true); | |
| 1775 } | |
| 1776 if (should_log) { | |
| 1777 ci_env.set_log(thread->log()); | |
| 1778 } | |
| 1779 assert(thread->env() == &ci_env, "set by ci_env"); | |
| 1780 // The thread-env() field is cleared in ~CompileTaskWrapper. | |
| 1781 | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
0
diff
changeset
|
1782 // Cache Jvmti state |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
0
diff
changeset
|
1783 ci_env.cache_jvmti_state(); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
0
diff
changeset
|
1784 |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
0
diff
changeset
|
1785 // Cache DTrace flags |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
0
diff
changeset
|
1786 ci_env.cache_dtrace_flags(); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
0
diff
changeset
|
1787 |
| 0 | 1788 ciMethod* target = ci_env.get_method_from_handle(target_handle); |
| 1789 | |
| 1790 TraceTime t1("compilation", &time); | |
| 1791 | |
| 1792 compiler(task->comp_level())->compile_method(&ci_env, target, osr_bci); | |
| 1793 | |
| 1794 if (!ci_env.failing() && task->code() == NULL) { | |
| 1795 //assert(false, "compiler should always document failure"); | |
| 1796 // The compiler elected, without comment, not to register a result. | |
| 1797 // Do not attempt further compilations of this method. | |
|
1964
22ef3370343b
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
1783
diff
changeset
|
1798 ci_env.record_method_not_compilable("compile failed", !TieredCompilation); |
| 0 | 1799 } |
| 1800 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1801 // Copy this bit to the enclosing block: |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1802 compilable = ci_env.compilable(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1803 |
| 0 | 1804 if (ci_env.failing()) { |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1805 const char* retry_message = ci_env.retry_message(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1806 if (_compilation_log != NULL) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1807 _compilation_log->log_failure(thread, task, ci_env.failure_reason(), retry_message); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1808 } |
| 0 | 1809 if (PrintCompilation) { |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1810 FormatBufferResource msg = retry_message != NULL ? |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1811 err_msg_res("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) : |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1812 err_msg_res("COMPILE SKIPPED: %s", ci_env.failure_reason()); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1813 task->print_compilation(tty, msg); |
| 0 | 1814 } |
| 1815 } else { | |
| 1816 task->mark_success(); | |
| 1817 task->set_num_inlined_bytecodes(ci_env.num_inlined_bytecodes()); | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1818 if (_compilation_log != NULL) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1819 nmethod* code = task->code(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1820 if (code != NULL) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1821 _compilation_log->log_nmethod(thread, code); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1822 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4825
diff
changeset
|
1823 } |
| 0 | 1824 } |
| 1825 } | |
| 1826 pop_jni_handle_block(); | |
| 1827 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1828 methodHandle method(thread, task->method()); |
| 0 | 1829 |
| 1830 DTRACE_METHOD_COMPILE_END_PROBE(compiler(task->comp_level()), method, task->is_success()); | |
| 1831 | |
| 1832 collect_statistics(thread, time, task); | |
| 1833 | |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
4047
diff
changeset
|
1834 if (PrintCompilation && PrintCompilation2) { |
| 4047 | 1835 tty->print("%7d ", (int) tty->time_stamp().milliseconds()); // print timestamp |
| 1836 tty->print("%4d ", compile_id); // print compilation number | |
| 1837 tty->print("%s ", (is_osr ? "%" : " ")); | |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
4047
diff
changeset
|
1838 int code_size = (task->code() == NULL) ? 0 : task->code()->total_size(); |
|
4122
cc81b9c09bbb
7112478: after 7105605 JRuby bench_define_method_methods.rb fails with NPE
kvn
parents:
4064
diff
changeset
|
1839 tty->print_cr("size: %d time: %d inlined: %d bytes", code_size, (int)time.milliseconds(), task->num_inlined_bytecodes()); |
| 4047 | 1840 } |
| 1841 | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1842 // Disable compilation, if required. |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1843 switch (compilable) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1844 case ciEnv::MethodCompilable_never: |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1845 if (is_osr) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1846 method->set_not_osr_compilable_quietly(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1847 else |
|
1208
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1202
diff
changeset
|
1848 method->set_not_compilable_quietly(); |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1849 break; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1850 case ciEnv::MethodCompilable_not_at_tier: |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1851 if (is_osr) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1852 method->set_not_osr_compilable_quietly(task->comp_level()); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1853 else |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1854 method->set_not_compilable_quietly(task->comp_level()); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
1855 break; |
| 0 | 1856 } |
| 1857 | |
| 1858 // Note that the queued_for_compilation bits are cleared without | |
| 1859 // protection of a mutex. [They were set by the requester thread, | |
| 1860 // when adding the task to the complie queue -- at which time the | |
| 1861 // compile queue lock was held. Subsequently, we acquired the compile | |
| 1862 // queue lock to get this task off the compile queue; thus (to belabour | |
| 1863 // the point somewhat) our clearing of the bits must be occurring | |
| 1864 // only after the setting of the bits. See also 14012000 above. | |
| 1865 method->clear_queued_for_compilation(); | |
| 1866 | |
| 1867 #ifdef ASSERT | |
| 1868 if (CollectedHeap::fired_fake_oom()) { | |
| 1869 // The current compile received a fake OOM during compilation so | |
| 1870 // go ahead and exit the VM since the test apparently succeeded | |
| 1871 tty->print_cr("*** Shutting down VM after successful fake OOM"); | |
| 1872 vm_exit(0); | |
| 1873 } | |
| 1874 #endif | |
| 1875 } | |
| 1876 | |
| 1877 // ------------------------------------------------------------------ | |
| 1202 | 1878 // CompileBroker::handle_full_code_cache |
| 1879 // | |
| 1880 // The CodeCache is full. Print out warning and disable compilation or | |
| 1881 // try code cache cleaning so compilation can continue later. | |
| 1882 void CompileBroker::handle_full_code_cache() { | |
| 1883 UseInterpreter = true; | |
| 1884 if (UseCompiler || AlwaysCompileLoopMethods ) { | |
|
1728
a62d332029cf
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
1692
diff
changeset
|
1885 if (xtty != NULL) { |
|
2482
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1886 stringStream s; |
|
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1887 // Dump code cache state into a buffer before locking the tty, |
|
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1888 // because log_state() will use locks causing lock conflicts. |
|
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1889 CodeCache::log_state(&s); |
|
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1890 // Lock to prevent tearing |
|
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1891 ttyLocker ttyl; |
|
1728
a62d332029cf
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
1692
diff
changeset
|
1892 xtty->begin_elem("code_cache_full"); |
|
2482
dbccacb79c63
7036236: VM crashes assert((!inside_attrs()) || is_error_reported()) failed ...
iveresov
parents:
2447
diff
changeset
|
1893 xtty->print(s.as_string()); |
|
1728
a62d332029cf
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
1692
diff
changeset
|
1894 xtty->stamp(); |
|
a62d332029cf
6976372: # assert(_owner == Thread::current()) failed: invariant
never
parents:
1692
diff
changeset
|
1895 xtty->end_elem(); |
| 1202 | 1896 } |
|
1578
ca3dceda776c
6930994: Code cache is full warning should be visible in product
never
parents:
1538
diff
changeset
|
1897 warning("CodeCache is full. Compiler has been disabled."); |
|
ca3dceda776c
6930994: Code cache is full warning should be visible in product
never
parents:
1538
diff
changeset
|
1898 warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize="); |
|
2353
1c0cf339481b
7025742: Can not use CodeCache::unallocated_capacity() with fragmented CodeCache
kvn
parents:
2260
diff
changeset
|
1899 CodeCache::print_bounds(tty); |
|
1578
ca3dceda776c
6930994: Code cache is full warning should be visible in product
never
parents:
1538
diff
changeset
|
1900 #ifndef PRODUCT |
| 1202 | 1901 if (CompileTheWorld || ExitOnFullCodeCache) { |
| 1902 before_exit(JavaThread::current()); | |
| 1903 exit_globals(); // will delete tty | |
| 1904 vm_direct_exit(CompileTheWorld ? 0 : 1); | |
| 1905 } | |
|
1578
ca3dceda776c
6930994: Code cache is full warning should be visible in product
never
parents:
1538
diff
changeset
|
1906 #endif |
| 1202 | 1907 if (UseCodeCacheFlushing) { |
| 1908 NMethodSweeper::handle_full_code_cache(true); | |
| 1909 } else { | |
| 1910 UseCompiler = false; | |
| 1911 AlwaysCompileLoopMethods = false; | |
| 1912 } | |
| 1913 } | |
| 1914 } | |
| 1915 | |
| 1916 // ------------------------------------------------------------------ | |
| 0 | 1917 // CompileBroker::set_last_compile |
| 1918 // | |
| 1919 // Record this compilation for debugging purposes. | |
| 1920 void CompileBroker::set_last_compile(CompilerThread* thread, methodHandle method, bool is_osr, int comp_level) { | |
| 1921 ResourceMark rm; | |
| 1922 char* method_name = method->name()->as_C_string(); | |
| 1923 strncpy(_last_method_compiled, method_name, CompileBroker::name_buffer_length); | |
| 1924 char current_method[CompilerCounters::cmname_buffer_length]; | |
| 1925 size_t maxLen = CompilerCounters::cmname_buffer_length; | |
| 1926 | |
| 1927 if (UsePerfData) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1928 const char* class_name = method->method_holder()->name()->as_C_string(); |
| 0 | 1929 |
| 1930 size_t s1len = strlen(class_name); | |
| 1931 size_t s2len = strlen(method_name); | |
| 1932 | |
| 1933 // check if we need to truncate the string | |
| 1934 if (s1len + s2len + 2 > maxLen) { | |
| 1935 | |
| 1936 // the strategy is to lop off the leading characters of the | |
| 1937 // class name and the trailing characters of the method name. | |
| 1938 | |
| 1939 if (s2len + 2 > maxLen) { | |
| 1940 // lop of the entire class name string, let snprintf handle | |
| 1941 // truncation of the method name. | |
| 1942 class_name += s1len; // null string | |
| 1943 } | |
| 1944 else { | |
| 1945 // lop off the extra characters from the front of the class name | |
| 1946 class_name += ((s1len + s2len + 2) - maxLen); | |
| 1947 } | |
| 1948 } | |
| 1949 | |
| 1950 jio_snprintf(current_method, maxLen, "%s %s", class_name, method_name); | |
| 1951 } | |
| 1952 | |
| 1953 if (CICountOSR && is_osr) { | |
| 1954 _last_compile_type = osr_compile; | |
| 1955 } else { | |
| 1956 _last_compile_type = normal_compile; | |
| 1957 } | |
| 1958 _last_compile_level = comp_level; | |
| 1959 | |
| 1960 if (UsePerfData) { | |
| 1961 CompilerCounters* counters = thread->counters(); | |
| 1962 counters->set_current_method(current_method); | |
| 1963 counters->set_compile_type((jlong)_last_compile_type); | |
| 1964 } | |
| 1965 } | |
| 1966 | |
| 1967 | |
| 1968 // ------------------------------------------------------------------ | |
| 1969 // CompileBroker::push_jni_handle_block | |
| 1970 // | |
| 1971 // Push on a new block of JNI handles. | |
| 1972 void CompileBroker::push_jni_handle_block() { | |
| 1973 JavaThread* thread = JavaThread::current(); | |
| 1974 | |
| 1975 // Allocate a new block for JNI handles. | |
| 1976 // Inlined code from jni_PushLocalFrame() | |
| 1977 JNIHandleBlock* java_handles = thread->active_handles(); | |
| 1978 JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread); | |
| 1979 assert(compile_handles != NULL && java_handles != NULL, "should not be NULL"); | |
| 1980 compile_handles->set_pop_frame_link(java_handles); // make sure java handles get gc'd. | |
| 1981 thread->set_active_handles(compile_handles); | |
| 1982 } | |
| 1983 | |
| 1984 | |
| 1985 // ------------------------------------------------------------------ | |
| 1986 // CompileBroker::pop_jni_handle_block | |
| 1987 // | |
| 1988 // Pop off the current block of JNI handles. | |
| 1989 void CompileBroker::pop_jni_handle_block() { | |
| 1990 JavaThread* thread = JavaThread::current(); | |
| 1991 | |
| 1992 // Release our JNI handle block | |
| 1993 JNIHandleBlock* compile_handles = thread->active_handles(); | |
| 1994 JNIHandleBlock* java_handles = compile_handles->pop_frame_link(); | |
| 1995 thread->set_active_handles(java_handles); | |
| 1996 compile_handles->set_pop_frame_link(NULL); | |
| 1997 JNIHandleBlock::release_block(compile_handles, thread); // may block | |
| 1998 } | |
| 1999 | |
| 2000 | |
| 2001 // ------------------------------------------------------------------ | |
| 2002 // CompileBroker::check_break_at | |
| 2003 // | |
| 2004 // Should the compilation break at the current compilation. | |
| 2005 bool CompileBroker::check_break_at(methodHandle method, int compile_id, bool is_osr) { | |
| 2006 if (CICountOSR && is_osr && (compile_id == CIBreakAtOSR)) { | |
| 2007 return true; | |
| 2008 } else if( CompilerOracle::should_break_at(method) ) { // break when compiling | |
| 2009 return true; | |
| 2010 } else { | |
| 2011 return (compile_id == CIBreakAt); | |
| 2012 } | |
| 2013 } | |
| 2014 | |
| 2015 // ------------------------------------------------------------------ | |
| 2016 // CompileBroker::collect_statistics | |
| 2017 // | |
| 2018 // Collect statistics about the compilation. | |
| 2019 | |
| 2020 void CompileBroker::collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task) { | |
| 2021 bool success = task->is_success(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2022 methodHandle method (thread, task->method()); |
| 0 | 2023 uint compile_id = task->compile_id(); |
| 2024 bool is_osr = (task->osr_bci() != standard_entry_bci); | |
| 2025 nmethod* code = task->code(); | |
| 2026 CompilerCounters* counters = thread->counters(); | |
| 2027 | |
| 2028 assert(code == NULL || code->is_locked_by_vm(), "will survive the MutexLocker"); | |
| 2029 MutexLocker locker(CompileStatistics_lock); | |
| 2030 | |
| 2031 // _perf variables are production performance counters which are | |
| 2032 // updated regardless of the setting of the CITime and CITimeEach flags | |
| 2033 // | |
| 2034 if (!success) { | |
| 2035 _total_bailout_count++; | |
| 2036 if (UsePerfData) { | |
| 2037 _perf_last_failed_method->set_value(counters->current_method()); | |
| 2038 _perf_last_failed_type->set_value(counters->compile_type()); | |
| 2039 _perf_total_bailout_count->inc(); | |
| 2040 } | |
| 2041 } else if (code == NULL) { | |
| 2042 if (UsePerfData) { | |
| 2043 _perf_last_invalidated_method->set_value(counters->current_method()); | |
| 2044 _perf_last_invalidated_type->set_value(counters->compile_type()); | |
| 2045 _perf_total_invalidated_count->inc(); | |
| 2046 } | |
| 2047 _total_invalidated_count++; | |
| 2048 } else { | |
| 2049 // Compilation succeeded | |
| 2050 | |
| 2051 // update compilation ticks - used by the implementation of | |
| 2052 // java.lang.management.CompilationMBean | |
| 2053 _perf_total_compilation->inc(time.ticks()); | |
| 2054 | |
| 2055 if (CITime) { | |
| 2056 _t_total_compilation.add(time); | |
| 2057 if (is_osr) { | |
| 2058 _t_osr_compilation.add(time); | |
| 2059 _sum_osr_bytes_compiled += method->code_size() + task->num_inlined_bytecodes(); | |
| 2060 } else { | |
| 2061 _t_standard_compilation.add(time); | |
| 2062 _sum_standard_bytes_compiled += method->code_size() + task->num_inlined_bytecodes(); | |
| 2063 } | |
| 2064 } | |
| 2065 | |
| 2066 if (UsePerfData) { | |
| 2067 // save the name of the last method compiled | |
| 2068 _perf_last_method->set_value(counters->current_method()); | |
| 2069 _perf_last_compile_type->set_value(counters->compile_type()); | |
| 2070 _perf_last_compile_size->set_value(method->code_size() + | |
| 2071 task->num_inlined_bytecodes()); | |
| 2072 if (is_osr) { | |
| 2073 _perf_osr_compilation->inc(time.ticks()); | |
| 2074 _perf_sum_osr_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes()); | |
| 2075 } else { | |
| 2076 _perf_standard_compilation->inc(time.ticks()); | |
| 2077 _perf_sum_standard_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes()); | |
| 2078 } | |
| 2079 } | |
| 2080 | |
| 2081 if (CITimeEach) { | |
| 2082 float bytes_per_sec = 1.0 * (method->code_size() + task->num_inlined_bytecodes()) / time.seconds(); | |
| 2083 tty->print_cr("%3d seconds: %f bytes/sec : %f (bytes %d + %d inlined)", | |
| 2084 compile_id, time.seconds(), bytes_per_sec, method->code_size(), task->num_inlined_bytecodes()); | |
| 2085 } | |
| 2086 | |
| 2087 // Collect counts of successful compilations | |
| 1748 | 2088 _sum_nmethod_size += code->total_size(); |
| 2089 _sum_nmethod_code_size += code->insts_size(); | |
| 0 | 2090 _total_compile_count++; |
| 2091 | |
| 2092 if (UsePerfData) { | |
| 1748 | 2093 _perf_sum_nmethod_size->inc( code->total_size()); |
| 2094 _perf_sum_nmethod_code_size->inc(code->insts_size()); | |
| 0 | 2095 _perf_total_compile_count->inc(); |
| 2096 } | |
| 2097 | |
| 2098 if (is_osr) { | |
| 2099 if (UsePerfData) _perf_total_osr_compile_count->inc(); | |
| 2100 _total_osr_compile_count++; | |
| 2101 } else { | |
| 2102 if (UsePerfData) _perf_total_standard_compile_count->inc(); | |
| 2103 _total_standard_compile_count++; | |
| 2104 } | |
| 2105 } | |
| 2106 // set the current method for the thread to null | |
| 2107 if (UsePerfData) counters->set_current_method(""); | |
| 2108 } | |
| 2109 | |
| 2110 | |
| 2111 | |
| 2112 void CompileBroker::print_times() { | |
| 2113 tty->cr(); | |
| 2114 tty->print_cr("Accumulated compiler times (for compiled methods only)"); | |
| 2115 tty->print_cr("------------------------------------------------"); | |
| 2116 //0000000000111111111122222222223333333333444444444455555555556666666666 | |
| 2117 //0123456789012345678901234567890123456789012345678901234567890123456789 | |
| 2118 tty->print_cr(" Total compilation time : %6.3f s", CompileBroker::_t_total_compilation.seconds()); | |
| 2119 tty->print_cr(" Standard compilation : %6.3f s, Average : %2.3f", | |
| 2120 CompileBroker::_t_standard_compilation.seconds(), | |
| 2121 CompileBroker::_t_standard_compilation.seconds() / CompileBroker::_total_standard_compile_count); | |
| 2122 tty->print_cr(" On stack replacement : %6.3f s, Average : %2.3f", CompileBroker::_t_osr_compilation.seconds(), CompileBroker::_t_osr_compilation.seconds() / CompileBroker::_total_osr_compile_count); | |
| 1131 | 2123 |
| 1783 | 2124 if (compiler(CompLevel_simple) != NULL) { |
| 2125 compiler(CompLevel_simple)->print_timers(); | |
| 0 | 2126 } |
| 1783 | 2127 if (compiler(CompLevel_full_optimization) != NULL) { |
| 2128 compiler(CompLevel_full_optimization)->print_timers(); | |
| 2129 } | |
| 0 | 2130 tty->cr(); |
| 2131 int tcb = CompileBroker::_sum_osr_bytes_compiled + CompileBroker::_sum_standard_bytes_compiled; | |
| 2132 tty->print_cr(" Total compiled bytecodes : %6d bytes", tcb); | |
| 2133 tty->print_cr(" Standard compilation : %6d bytes", CompileBroker::_sum_standard_bytes_compiled); | |
| 2134 tty->print_cr(" On stack replacement : %6d bytes", CompileBroker::_sum_osr_bytes_compiled); | |
| 2135 int bps = (int)(tcb / CompileBroker::_t_total_compilation.seconds()); | |
| 2136 tty->print_cr(" Average compilation speed: %6d bytes/s", bps); | |
| 2137 tty->cr(); | |
| 2138 tty->print_cr(" nmethod code size : %6d bytes", CompileBroker::_sum_nmethod_code_size); | |
| 2139 tty->print_cr(" nmethod total size : %6d bytes", CompileBroker::_sum_nmethod_size); | |
| 2140 } | |
| 2141 | |
| 2142 | |
| 2143 // Debugging output for failure | |
| 2144 void CompileBroker::print_last_compile() { | |
| 2145 if ( _last_compile_level != CompLevel_none && | |
| 2146 compiler(_last_compile_level) != NULL && | |
| 2147 _last_method_compiled != NULL && | |
| 2148 _last_compile_type != no_compile) { | |
| 2149 if (_last_compile_type == osr_compile) { | |
| 2150 tty->print_cr("Last parse: [osr]%d+++(%d) %s", | |
| 2151 _osr_compilation_id, _last_compile_level, _last_method_compiled); | |
| 2152 } else { | |
| 2153 tty->print_cr("Last parse: %d+++(%d) %s", | |
| 2154 _compilation_id, _last_compile_level, _last_method_compiled); | |
| 2155 } | |
| 2156 } | |
| 2157 } | |
| 2158 | |
| 2159 | |
| 2160 void CompileBroker::print_compiler_threads_on(outputStream* st) { | |
| 2161 #ifndef PRODUCT | |
| 2162 st->print_cr("Compiler thread printing unimplemented."); | |
| 2163 st->cr(); | |
| 2164 #endif | |
| 2165 } |