Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/compilationPolicy.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | 18fb7da42534 |
| children | 2cb439954abf b84fd7d73702 aeaca88565e6 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
2 * Copyright (c) 2000, 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:
1202
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1202
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:
1202
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "code/compiledIC.hpp" | |
| 27 #include "code/nmethod.hpp" | |
| 28 #include "code/scopeDesc.hpp" | |
| 29 #include "compiler/compilerOracle.hpp" | |
| 30 #include "interpreter/interpreter.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
31 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
32 #include "oops/method.hpp" |
| 1972 | 33 #include "oops/oop.inline.hpp" |
| 34 #include "prims/nativeLookup.hpp" | |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
35 #include "runtime/advancedThresholdPolicy.hpp" |
| 1972 | 36 #include "runtime/compilationPolicy.hpp" |
| 37 #include "runtime/frame.hpp" | |
| 38 #include "runtime/handles.inline.hpp" | |
| 39 #include "runtime/rframe.hpp" | |
| 40 #include "runtime/simpleThresholdPolicy.hpp" | |
| 41 #include "runtime/stubRoutines.hpp" | |
| 42 #include "runtime/thread.hpp" | |
| 43 #include "runtime/timer.hpp" | |
| 44 #include "runtime/vframe.hpp" | |
| 45 #include "runtime/vm_operations.hpp" | |
| 46 #include "utilities/events.hpp" | |
| 47 #include "utilities/globalDefinitions.hpp" | |
| 0 | 48 |
| 49 CompilationPolicy* CompilationPolicy::_policy; | |
| 50 elapsedTimer CompilationPolicy::_accumulated_time; | |
| 51 bool CompilationPolicy::_in_vm_startup; | |
| 52 | |
| 53 // Determine compilation policy based on command line argument | |
| 54 void compilationPolicy_init() { | |
| 55 CompilationPolicy::set_in_vm_startup(DelayCompilationDuringStartup); | |
| 56 | |
| 57 switch(CompilationPolicyChoice) { | |
| 58 case 0: | |
| 59 CompilationPolicy::set_policy(new SimpleCompPolicy()); | |
| 60 break; | |
| 61 | |
| 62 case 1: | |
| 63 #ifdef COMPILER2 | |
| 64 CompilationPolicy::set_policy(new StackWalkCompPolicy()); | |
| 65 #else | |
| 66 Unimplemented(); | |
| 67 #endif | |
| 68 break; | |
| 1783 | 69 case 2: |
| 70 #ifdef TIERED | |
| 71 CompilationPolicy::set_policy(new SimpleThresholdPolicy()); | |
| 72 #else | |
| 73 Unimplemented(); | |
| 74 #endif | |
| 75 break; | |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
76 case 3: |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
77 #ifdef TIERED |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
78 CompilationPolicy::set_policy(new AdvancedThresholdPolicy()); |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
79 #else |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
80 Unimplemented(); |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
81 #endif |
|
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
82 break; |
| 0 | 83 default: |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
84 fatal("CompilationPolicyChoice must be in the range: [0-3]"); |
| 0 | 85 } |
| 1783 | 86 CompilationPolicy::policy()->initialize(); |
| 0 | 87 } |
| 88 | |
| 89 void CompilationPolicy::completed_vm_startup() { | |
| 90 if (TraceCompilationPolicy) { | |
| 91 tty->print("CompilationPolicy: completed vm startup.\n"); | |
| 92 } | |
| 93 _in_vm_startup = false; | |
| 94 } | |
| 95 | |
| 96 // Returns true if m must be compiled before executing it | |
| 97 // This is intended to force compiles for methods (usually for | |
| 98 // debugging) that would otherwise be interpreted for some reason. | |
| 1783 | 99 bool CompilationPolicy::must_be_compiled(methodHandle m, int comp_level) { |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
100 // Don't allow Xcomp to cause compiles in replay mode |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
101 if (ReplayCompiles) return false; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
102 |
| 0 | 103 if (m->has_compiled_code()) return false; // already compiled |
| 1783 | 104 if (!can_be_compiled(m, comp_level)) return false; |
| 0 | 105 |
| 106 return !UseInterpreter || // must compile all methods | |
| 1202 | 107 (UseCompiler && AlwaysCompileLoopMethods && m->has_loops() && CompileBroker::should_compile_new_jobs()); // eagerly compile loop methods |
| 0 | 108 } |
| 109 | |
| 110 // Returns true if m is allowed to be compiled | |
| 1783 | 111 bool CompilationPolicy::can_be_compiled(methodHandle m, int comp_level) { |
| 0 | 112 if (m->is_abstract()) return false; |
| 113 if (DontCompileHugeMethods && m->code_size() > HugeMethodLimit) return false; | |
| 114 | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
115 // Math intrinsics should never be compiled as this can lead to |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
116 // monotonicity problems because the interpreter will prefer the |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
117 // compiled code to the intrinsic version. This can't happen in |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
118 // production because the invocation counter can't be incremented |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
119 // but we shouldn't expose the system to this problem in testing |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
120 // modes. |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
121 if (!AbstractInterpreter::can_be_compiled(m)) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
122 return false; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
123 } |
| 1783 | 124 if (comp_level == CompLevel_all) { |
| 125 return !m->is_not_compilable(CompLevel_simple) && !m->is_not_compilable(CompLevel_full_optimization); | |
| 126 } else { | |
| 127 return !m->is_not_compilable(comp_level); | |
| 128 } | |
| 129 } | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
130 |
| 1783 | 131 bool CompilationPolicy::is_compilation_enabled() { |
| 132 // NOTE: CompileBroker::should_compile_new_jobs() checks for UseCompiler | |
| 133 return !delay_compilation_during_startup() && CompileBroker::should_compile_new_jobs(); | |
| 0 | 134 } |
| 135 | |
| 136 #ifndef PRODUCT | |
| 137 void CompilationPolicy::print_time() { | |
| 138 tty->print_cr ("Accumulated compilationPolicy times:"); | |
| 139 tty->print_cr ("---------------------------"); | |
| 140 tty->print_cr (" Total: %3.3f sec.", _accumulated_time.seconds()); | |
| 141 } | |
| 142 | |
| 1783 | 143 void NonTieredCompPolicy::trace_osr_completion(nmethod* osr_nm) { |
| 0 | 144 if (TraceOnStackReplacement) { |
| 145 if (osr_nm == NULL) tty->print_cr("compilation failed"); | |
| 146 else tty->print_cr("nmethod " INTPTR_FORMAT, osr_nm); | |
| 147 } | |
| 148 } | |
| 149 #endif // !PRODUCT | |
| 150 | |
| 1783 | 151 void NonTieredCompPolicy::initialize() { |
| 152 // Setup the compiler thread numbers | |
| 153 if (CICompilerCountPerCPU) { | |
| 154 // Example: if CICompilerCountPerCPU is true, then we get | |
| 155 // max(log2(8)-1,1) = 2 compiler threads on an 8-way machine. | |
| 156 // May help big-app startup time. | |
| 157 _compiler_count = MAX2(log2_intptr(os::active_processor_count())-1,1); | |
| 158 } else { | |
| 159 _compiler_count = CICompilerCount; | |
| 160 } | |
| 161 } | |
| 162 | |
|
1821
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
163 // Note: this policy is used ONLY if TieredCompilation is off. |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
164 // compiler_count() behaves the following way: |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
165 // - with TIERED build (with both COMPILER1 and COMPILER2 defined) it should return |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
166 // zero for the c1 compilation levels, hence the particular ordering of the |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
167 // statements. |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
168 // - the same should happen when COMPILER2 is defined and COMPILER1 is not |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
169 // (server build without TIERED defined). |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
170 // - if only COMPILER1 is defined (client build), zero should be returned for |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
171 // the c2 level. |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
172 // - if neither is defined - always return zero. |
| 1783 | 173 int NonTieredCompPolicy::compiler_count(CompLevel comp_level) { |
|
1821
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
174 assert(!TieredCompilation, "This policy should not be used with TieredCompilation"); |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
175 #ifdef COMPILER2 |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
176 if (is_c2_compile(comp_level)) { |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
177 return _compiler_count; |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
178 } else { |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
179 return 0; |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
180 } |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
181 #endif |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
182 |
| 1783 | 183 #ifdef COMPILER1 |
| 184 if (is_c1_compile(comp_level)) { | |
| 185 return _compiler_count; | |
|
1821
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
186 } else { |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
187 return 0; |
| 1783 | 188 } |
| 189 #endif | |
| 190 | |
| 191 return 0; | |
| 192 } | |
| 193 | |
| 194 void NonTieredCompPolicy::reset_counter_for_invocation_event(methodHandle m) { | |
| 0 | 195 // Make sure invocation and backedge counter doesn't overflow again right away |
| 196 // as would be the case for native methods. | |
| 197 | |
| 198 // BUT also make sure the method doesn't look like it was never executed. | |
| 199 // Set carry bit and reduce counter's value to min(count, CompileThreshold/2). | |
| 200 m->invocation_counter()->set_carry(); | |
| 201 m->backedge_counter()->set_carry(); | |
| 202 | |
| 203 assert(!m->was_never_executed(), "don't reset to 0 -- could be mistaken for never-executed"); | |
| 204 } | |
| 205 | |
| 1783 | 206 void NonTieredCompPolicy::reset_counter_for_back_branch_event(methodHandle m) { |
| 0 | 207 // Delay next back-branch event but pump up invocation counter to triger |
| 208 // whole method compilation. | |
| 209 InvocationCounter* i = m->invocation_counter(); | |
| 210 InvocationCounter* b = m->backedge_counter(); | |
| 211 | |
| 212 // Don't set invocation_counter's value too low otherwise the method will | |
| 213 // look like immature (ic < ~5300) which prevents the inlining based on | |
| 214 // the type profiling. | |
| 215 i->set(i->state(), CompileThreshold); | |
| 216 // Don't reset counter too low - it is used to check if OSR method is ready. | |
| 217 b->set(b->state(), CompileThreshold / 2); | |
| 218 } | |
| 219 | |
| 1783 | 220 // |
| 221 // CounterDecay | |
| 222 // | |
| 223 // Interates through invocation counters and decrements them. This | |
| 224 // is done at each safepoint. | |
| 225 // | |
| 226 class CounterDecay : public AllStatic { | |
| 227 static jlong _last_timestamp; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
228 static void do_method(Method* m) { |
| 1783 | 229 m->invocation_counter()->decay(); |
| 230 } | |
| 231 public: | |
| 232 static void decay(); | |
| 233 static bool is_decay_needed() { | |
| 234 return (os::javaTimeMillis() - _last_timestamp) > CounterDecayMinIntervalLength; | |
| 235 } | |
| 236 }; | |
| 237 | |
| 238 jlong CounterDecay::_last_timestamp = 0; | |
| 239 | |
| 240 void CounterDecay::decay() { | |
| 241 _last_timestamp = os::javaTimeMillis(); | |
| 242 | |
| 243 // This operation is going to be performed only at the end of a safepoint | |
| 244 // and hence GC's will not be going on, all Java mutators are suspended | |
| 245 // at this point and hence SystemDictionary_lock is also not needed. | |
| 246 assert(SafepointSynchronize::is_at_safepoint(), "can only be executed at a safepoint"); | |
| 247 int nclasses = SystemDictionary::number_of_classes(); | |
| 248 double classes_per_tick = nclasses * (CounterDecayMinIntervalLength * 1e-3 / | |
| 249 CounterHalfLifeTime); | |
| 250 for (int i = 0; i < classes_per_tick; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
251 Klass* k = SystemDictionary::try_get_next_class(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
252 if (k != NULL && k->oop_is_instance()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
253 InstanceKlass::cast(k)->methods_do(do_method); |
| 1783 | 254 } |
| 255 } | |
| 256 } | |
| 257 | |
| 258 // Called at the end of the safepoint | |
| 259 void NonTieredCompPolicy::do_safepoint_work() { | |
| 260 if(UseCounterDecay && CounterDecay::is_decay_needed()) { | |
| 261 CounterDecay::decay(); | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 void NonTieredCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) { | |
| 266 ScopeDesc* sd = trap_scope; | |
| 267 for (; !sd->is_top(); sd = sd->sender()) { | |
| 268 // Reset ICs of inlined methods, since they can trigger compilations also. | |
| 269 sd->method()->invocation_counter()->reset(); | |
| 270 } | |
| 271 InvocationCounter* c = sd->method()->invocation_counter(); | |
| 272 if (is_osr) { | |
| 273 // It was an OSR method, so bump the count higher. | |
| 274 c->set(c->state(), CompileThreshold); | |
| 275 } else { | |
| 276 c->reset(); | |
| 277 } | |
| 278 sd->method()->backedge_counter()->reset(); | |
| 279 } | |
| 280 | |
| 281 // This method can be called by any component of the runtime to notify the policy | |
| 282 // that it's recommended to delay the complation of this method. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
283 void NonTieredCompPolicy::delay_compilation(Method* method) { |
| 1783 | 284 method->invocation_counter()->decay(); |
| 285 method->backedge_counter()->decay(); | |
| 286 } | |
| 287 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
288 void NonTieredCompPolicy::disable_compilation(Method* method) { |
| 1783 | 289 method->invocation_counter()->set_state(InvocationCounter::wait_for_nothing); |
| 290 method->backedge_counter()->set_state(InvocationCounter::wait_for_nothing); | |
| 291 } | |
| 292 | |
| 293 CompileTask* NonTieredCompPolicy::select_task(CompileQueue* compile_queue) { | |
| 294 return compile_queue->first(); | |
| 295 } | |
| 296 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
297 bool NonTieredCompPolicy::is_mature(Method* method) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
298 MethodData* mdo = method->method_data(); |
| 1783 | 299 assert(mdo != NULL, "Should be"); |
| 300 uint current = mdo->mileage_of(method); | |
| 301 uint initial = mdo->creation_mileage(); | |
| 302 if (current < initial) | |
| 303 return true; // some sort of overflow | |
| 304 uint target; | |
| 305 if (ProfileMaturityPercentage <= 0) | |
| 306 target = (uint) -ProfileMaturityPercentage; // absolute value | |
| 307 else | |
| 308 target = (uint)( (ProfileMaturityPercentage * CompileThreshold) / 100 ); | |
| 309 return (current >= initial + target); | |
| 310 } | |
| 311 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
312 nmethod* NonTieredCompPolicy::event(methodHandle method, methodHandle inlinee, int branch_bci, |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
313 int bci, CompLevel comp_level, nmethod* nm, JavaThread* thread) { |
| 1783 | 314 assert(comp_level == CompLevel_none, "This should be only called from the interpreter"); |
| 315 NOT_PRODUCT(trace_frequency_counter_overflow(method, branch_bci, bci)); | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
316 if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) { |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
317 // If certain JVMTI events (e.g. frame pop event) are requested then the |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
318 // thread is forced to remain in interpreted code. This is |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
319 // implemented partly by a check in the run_compiled_code |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
320 // section of the interpreter whether we should skip running |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
321 // compiled code, and partly by skipping OSR compiles for |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
322 // interpreted-only threads. |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
323 if (bci != InvocationEntryBci) { |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
324 reset_counter_for_back_branch_event(method); |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
325 return NULL; |
| 1783 | 326 } |
| 327 } | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
328 if (CompileTheWorld || ReplayCompiles) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
329 // Don't trigger other compiles in testing mode |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
330 if (bci == InvocationEntryBci) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
331 reset_counter_for_invocation_event(method); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
332 } else { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
333 reset_counter_for_back_branch_event(method); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
334 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
335 return NULL; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
336 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
337 |
| 1783 | 338 if (bci == InvocationEntryBci) { |
| 339 // when code cache is full, compilation gets switched off, UseCompiler | |
| 340 // is set to false | |
| 341 if (!method->has_compiled_code() && UseCompiler) { | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
342 method_invocation_event(method, thread); |
| 1783 | 343 } else { |
| 344 // Force counter overflow on method entry, even if no compilation | |
| 345 // happened. (The method_invocation_event call does this also.) | |
| 346 reset_counter_for_invocation_event(method); | |
| 347 } | |
| 348 // compilation at an invocation overflow no longer goes and retries test for | |
| 349 // compiled method. We always run the loser of the race as interpreted. | |
| 350 // so return NULL | |
| 351 return NULL; | |
| 352 } else { | |
| 353 // counter overflow in a loop => try to do on-stack-replacement | |
| 354 nmethod* osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true); | |
| 355 NOT_PRODUCT(trace_osr_request(method, osr_nm, bci)); | |
| 356 // when code cache is full, we should not compile any more... | |
| 357 if (osr_nm == NULL && UseCompiler) { | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
358 method_back_branch_event(method, bci, thread); |
| 1783 | 359 osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true); |
| 360 } | |
| 361 if (osr_nm == NULL) { | |
| 362 reset_counter_for_back_branch_event(method); | |
| 363 return NULL; | |
| 364 } | |
| 365 return osr_nm; | |
| 366 } | |
| 367 return NULL; | |
| 368 } | |
| 369 | |
| 370 #ifndef PRODUCT | |
| 371 void NonTieredCompPolicy::trace_frequency_counter_overflow(methodHandle m, int branch_bci, int bci) { | |
| 372 if (TraceInvocationCounterOverflow) { | |
| 373 InvocationCounter* ic = m->invocation_counter(); | |
| 374 InvocationCounter* bc = m->backedge_counter(); | |
| 375 ResourceMark rm; | |
| 376 const char* msg = | |
| 377 bci == InvocationEntryBci | |
| 378 ? "comp-policy cntr ovfl @ %d in entry of " | |
| 379 : "comp-policy cntr ovfl @ %d in loop of "; | |
| 380 tty->print(msg, bci); | |
| 381 m->print_value(); | |
| 382 tty->cr(); | |
| 383 ic->print(); | |
| 384 bc->print(); | |
| 385 if (ProfileInterpreter) { | |
| 386 if (bci != InvocationEntryBci) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
387 MethodData* mdo = m->method_data(); |
| 1783 | 388 if (mdo != NULL) { |
| 389 int count = mdo->bci_to_data(branch_bci)->as_JumpData()->taken(); | |
| 390 tty->print_cr("back branch count = %d", count); | |
| 391 } | |
| 392 } | |
| 393 } | |
| 394 } | |
| 395 } | |
| 396 | |
| 397 void NonTieredCompPolicy::trace_osr_request(methodHandle method, nmethod* osr, int bci) { | |
| 398 if (TraceOnStackReplacement) { | |
| 399 ResourceMark rm; | |
| 400 tty->print(osr != NULL ? "Reused OSR entry for " : "Requesting OSR entry for "); | |
| 401 method->print_short_name(tty); | |
| 402 tty->print_cr(" at bci %d", bci); | |
| 403 } | |
| 404 } | |
| 405 #endif // !PRODUCT | |
| 406 | |
| 0 | 407 // SimpleCompPolicy - compile current method |
| 408 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
409 void SimpleCompPolicy::method_invocation_event(methodHandle m, JavaThread* thread) { |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
410 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
411 const int hot_count = m->invocation_count(); |
| 0 | 412 reset_counter_for_invocation_event(m); |
| 413 const char* comment = "count"; | |
| 414 | |
| 1783 | 415 if (is_compilation_enabled() && can_be_compiled(m)) { |
| 0 | 416 nmethod* nm = m->code(); |
| 417 if (nm == NULL ) { | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
418 CompileBroker::compile_method(m, InvocationEntryBci, comp_level, m, hot_count, comment, thread); |
| 0 | 419 } |
| 420 } | |
| 421 } | |
| 422 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
423 void SimpleCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) { |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
424 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
425 const int hot_count = m->backedge_count(); |
| 0 | 426 const char* comment = "backedge_count"; |
| 427 | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
428 if (is_compilation_enabled() && !m->is_not_osr_compilable(comp_level) && can_be_compiled(m)) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
429 CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
430 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));) |
| 0 | 431 } |
| 432 } | |
| 433 // StackWalkCompPolicy - walk up stack to find a suitable method to compile | |
| 434 | |
| 435 #ifdef COMPILER2 | |
| 436 const char* StackWalkCompPolicy::_msg = NULL; | |
| 437 | |
| 438 | |
| 439 // Consider m for compilation | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
440 void StackWalkCompPolicy::method_invocation_event(methodHandle m, JavaThread* thread) { |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
441 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
442 const int hot_count = m->invocation_count(); |
| 0 | 443 reset_counter_for_invocation_event(m); |
| 444 const char* comment = "count"; | |
| 445 | |
| 1783 | 446 if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(m)) { |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
447 ResourceMark rm(thread); |
| 0 | 448 frame fr = thread->last_frame(); |
| 449 assert(fr.is_interpreted_frame(), "must be interpreted"); | |
| 450 assert(fr.interpreter_frame_method() == m(), "bad method"); | |
| 451 | |
| 452 if (TraceCompilationPolicy) { | |
| 453 tty->print("method invocation trigger: "); | |
| 454 m->print_short_name(tty); | |
| 455 tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)m(), m->code_size()); | |
| 456 } | |
| 457 RegisterMap reg_map(thread, false); | |
| 458 javaVFrame* triggerVF = thread->last_java_vframe(®_map); | |
| 459 // triggerVF is the frame that triggered its counter | |
| 460 RFrame* first = new InterpretedRFrame(triggerVF->fr(), thread, m); | |
| 461 | |
| 462 if (first->top_method()->code() != NULL) { | |
| 463 // called obsolete method/nmethod -- no need to recompile | |
| 464 if (TraceCompilationPolicy) tty->print_cr(" --> " INTPTR_FORMAT, first->top_method()->code()); | |
| 465 } else { | |
| 466 if (TimeCompilationPolicy) accumulated_time()->start(); | |
| 467 GrowableArray<RFrame*>* stack = new GrowableArray<RFrame*>(50); | |
| 468 stack->push(first); | |
| 469 RFrame* top = findTopInlinableFrame(stack); | |
| 470 if (TimeCompilationPolicy) accumulated_time()->stop(); | |
| 471 assert(top != NULL, "findTopInlinableFrame returned null"); | |
| 472 if (TraceCompilationPolicy) top->print(); | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
473 CompileBroker::compile_method(top->top_method(), InvocationEntryBci, comp_level, |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
474 m, hot_count, comment, thread); |
| 0 | 475 } |
| 476 } | |
| 477 } | |
| 478 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
479 void StackWalkCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) { |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
480 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
481 const int hot_count = m->backedge_count(); |
| 0 | 482 const char* comment = "backedge_count"; |
| 483 | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
484 if (is_compilation_enabled() && !m->is_not_osr_compilable(comp_level) && can_be_compiled(m)) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
485 CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
486 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));) |
| 0 | 487 } |
| 488 } | |
| 489 | |
| 490 RFrame* StackWalkCompPolicy::findTopInlinableFrame(GrowableArray<RFrame*>* stack) { | |
| 491 // go up the stack until finding a frame that (probably) won't be inlined | |
| 492 // into its caller | |
| 493 RFrame* current = stack->at(0); // current choice for stopping | |
| 494 assert( current && !current->is_compiled(), "" ); | |
| 495 const char* msg = NULL; | |
| 496 | |
| 497 while (1) { | |
| 498 | |
| 499 // before going up the stack further, check if doing so would get us into | |
| 500 // compiled code | |
| 501 RFrame* next = senderOf(current, stack); | |
| 502 if( !next ) // No next frame up the stack? | |
| 503 break; // Then compile with current frame | |
| 504 | |
| 505 methodHandle m = current->top_method(); | |
| 506 methodHandle next_m = next->top_method(); | |
| 507 | |
| 508 if (TraceCompilationPolicy && Verbose) { | |
| 509 tty->print("[caller: "); | |
| 510 next_m->print_short_name(tty); | |
| 511 tty->print("] "); | |
| 512 } | |
| 513 | |
| 514 if( !Inline ) { // Inlining turned off | |
| 515 msg = "Inlining turned off"; | |
| 516 break; | |
| 517 } | |
| 518 if (next_m->is_not_compilable()) { // Did fail to compile this before/ | |
| 519 msg = "caller not compilable"; | |
| 520 break; | |
| 521 } | |
| 522 if (next->num() > MaxRecompilationSearchLength) { | |
| 523 // don't go up too high when searching for recompilees | |
| 524 msg = "don't go up any further: > MaxRecompilationSearchLength"; | |
| 525 break; | |
| 526 } | |
| 527 if (next->distance() > MaxInterpretedSearchLength) { | |
| 528 // don't go up too high when searching for recompilees | |
| 529 msg = "don't go up any further: next > MaxInterpretedSearchLength"; | |
| 530 break; | |
| 531 } | |
| 532 // Compiled frame above already decided not to inline; | |
| 533 // do not recompile him. | |
| 534 if (next->is_compiled()) { | |
| 535 msg = "not going up into optimized code"; | |
| 536 break; | |
| 537 } | |
| 538 | |
| 539 // Interpreted frame above us was already compiled. Do not force | |
| 540 // a recompile, although if the frame above us runs long enough an | |
| 541 // OSR might still happen. | |
| 542 if( current->is_interpreted() && next_m->has_compiled_code() ) { | |
| 543 msg = "not going up -- already compiled caller"; | |
| 544 break; | |
| 545 } | |
| 546 | |
| 547 // Compute how frequent this call site is. We have current method 'm'. | |
| 548 // We know next method 'next_m' is interpreted. Find the call site and | |
| 549 // check the various invocation counts. | |
| 550 int invcnt = 0; // Caller counts | |
| 551 if (ProfileInterpreter) { | |
| 552 invcnt = next_m->interpreter_invocation_count(); | |
| 553 } | |
| 554 int cnt = 0; // Call site counts | |
| 555 if (ProfileInterpreter && next_m->method_data() != NULL) { | |
| 556 ResourceMark rm; | |
| 557 int bci = next->top_vframe()->bci(); | |
| 558 ProfileData* data = next_m->method_data()->bci_to_data(bci); | |
| 559 if (data != NULL && data->is_CounterData()) | |
| 560 cnt = data->as_CounterData()->count(); | |
| 561 } | |
| 562 | |
| 563 // Caller counts / call-site counts; i.e. is this call site | |
| 564 // a hot call site for method next_m? | |
| 565 int freq = (invcnt) ? cnt/invcnt : cnt; | |
| 566 | |
| 567 // Check size and frequency limits | |
| 568 if ((msg = shouldInline(m, freq, cnt)) != NULL) { | |
| 569 break; | |
| 570 } | |
| 571 // Check inlining negative tests | |
| 572 if ((msg = shouldNotInline(m)) != NULL) { | |
| 573 break; | |
| 574 } | |
| 575 | |
| 576 | |
| 577 // If the caller method is too big or something then we do not want to | |
| 578 // compile it just to inline a method | |
| 1783 | 579 if (!can_be_compiled(next_m)) { |
| 0 | 580 msg = "caller cannot be compiled"; |
| 581 break; | |
| 582 } | |
| 583 | |
| 584 if( next_m->name() == vmSymbols::class_initializer_name() ) { | |
| 585 msg = "do not compile class initializer (OSR ok)"; | |
| 586 break; | |
| 587 } | |
| 588 | |
| 589 if (TraceCompilationPolicy && Verbose) { | |
| 590 tty->print("\n\t check caller: "); | |
| 591 next_m->print_short_name(tty); | |
| 592 tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)next_m(), next_m->code_size()); | |
| 593 } | |
| 594 | |
| 595 current = next; | |
| 596 } | |
| 597 | |
| 598 assert( !current || !current->is_compiled(), "" ); | |
| 599 | |
| 600 if (TraceCompilationPolicy && msg) tty->print("(%s)\n", msg); | |
| 601 | |
| 602 return current; | |
| 603 } | |
| 604 | |
| 605 RFrame* StackWalkCompPolicy::senderOf(RFrame* rf, GrowableArray<RFrame*>* stack) { | |
| 606 RFrame* sender = rf->caller(); | |
| 607 if (sender && sender->num() == stack->length()) stack->push(sender); | |
| 608 return sender; | |
| 609 } | |
| 610 | |
| 611 | |
| 612 const char* StackWalkCompPolicy::shouldInline(methodHandle m, float freq, int cnt) { | |
| 613 // Allows targeted inlining | |
| 614 // positive filter: should send be inlined? returns NULL (--> yes) | |
| 615 // or rejection msg | |
| 616 int max_size = MaxInlineSize; | |
| 617 int cost = m->code_size(); | |
| 618 | |
| 619 // Check for too many throws (and not too huge) | |
| 620 if (m->interpreter_throwout_count() > InlineThrowCount && cost < InlineThrowMaxSize ) { | |
| 621 return NULL; | |
| 622 } | |
| 623 | |
| 624 // bump the max size if the call is frequent | |
| 625 if ((freq >= InlineFrequencyRatio) || (cnt >= InlineFrequencyCount)) { | |
| 626 if (TraceFrequencyInlining) { | |
| 627 tty->print("(Inlined frequent method)\n"); | |
| 628 m->print(); | |
| 629 } | |
| 630 max_size = FreqInlineSize; | |
| 631 } | |
| 632 if (cost > max_size) { | |
| 633 return (_msg = "too big"); | |
| 634 } | |
| 635 return NULL; | |
| 636 } | |
| 637 | |
| 638 | |
| 639 const char* StackWalkCompPolicy::shouldNotInline(methodHandle m) { | |
| 640 // negative filter: should send NOT be inlined? returns NULL (--> inline) or rejection msg | |
| 641 if (m->is_abstract()) return (_msg = "abstract method"); | |
| 642 // note: we allow ik->is_abstract() | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6800
diff
changeset
|
643 if (!m->method_holder()->is_initialized()) return (_msg = "method holder not initialized"); |
| 0 | 644 if (m->is_native()) return (_msg = "native method"); |
| 645 nmethod* m_code = m->code(); | |
| 1748 | 646 if (m_code != NULL && m_code->code_size() > InlineSmallCode) |
| 0 | 647 return (_msg = "already compiled into a big method"); |
| 648 | |
| 649 // use frequency-based objections only for non-trivial methods | |
| 650 if (m->code_size() <= MaxTrivialSize) return NULL; | |
| 651 if (UseInterpreter) { // don't use counts with -Xcomp | |
| 652 if ((m->code() == NULL) && m->was_never_executed()) return (_msg = "never executed"); | |
| 653 if (!m->was_executed_more_than(MIN2(MinInliningThreshold, CompileThreshold >> 1))) return (_msg = "executed < MinInliningThreshold times"); | |
| 654 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
655 if (Method::has_unloaded_classes_in_signature(m, JavaThread::current())) return (_msg = "unloaded signature classes"); |
| 0 | 656 |
| 657 return NULL; | |
| 658 } | |
| 659 | |
| 660 | |
| 661 | |
| 662 #endif // COMPILER2 |