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