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