Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/compilationPolicy.cpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | 2c359f27615c |
| children | 04b9a2566eec 20334ed5ed3c |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2348
5d8f5a6dced7
7020403: Add AdvancedCompilationPolicy for tiered
iveresov
parents:
1972
diff
changeset
|
2 * Copyright (c) 2000, 2011, 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" | |
| 31 #include "oops/methodDataOop.hpp" | |
| 32 #include "oops/methodOop.hpp" | |
| 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; | |
| 225 static void do_method(methodOop m) { | |
| 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++) { | |
| 248 klassOop k = SystemDictionary::try_get_next_class(); | |
| 249 if (k != NULL && k->klass_part()->oop_is_instance()) { | |
| 250 instanceKlass::cast(k)->methods_do(do_method); | |
| 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. | |
| 280 void NonTieredCompPolicy::delay_compilation(methodOop method) { | |
| 281 method->invocation_counter()->decay(); | |
| 282 method->backedge_counter()->decay(); | |
| 283 } | |
| 284 | |
| 285 void NonTieredCompPolicy::disable_compilation(methodOop method) { | |
| 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 | |
| 294 bool NonTieredCompPolicy::is_mature(methodOop method) { | |
| 295 methodDataOop mdo = method->method_data(); | |
| 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 | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
2413
diff
changeset
|
309 nmethod* NonTieredCompPolicy::event(methodHandle method, methodHandle inlinee, int branch_bci, int bci, CompLevel comp_level, nmethod* nm, TRAPS) { |
| 1783 | 310 assert(comp_level == CompLevel_none, "This should be only called from the interpreter"); |
| 311 NOT_PRODUCT(trace_frequency_counter_overflow(method, branch_bci, bci)); | |
| 312 if (JvmtiExport::can_post_interpreter_events()) { | |
| 313 assert(THREAD->is_Java_thread(), "Wrong type of thread"); | |
| 314 if (((JavaThread*)THREAD)->is_interp_only_mode()) { | |
| 315 // If certain JVMTI events (e.g. frame pop event) are requested then the | |
| 316 // thread is forced to remain in interpreted code. This is | |
| 317 // implemented partly by a check in the run_compiled_code | |
| 318 // section of the interpreter whether we should skip running | |
| 319 // compiled code, and partly by skipping OSR compiles for | |
| 320 // interpreted-only threads. | |
| 321 if (bci != InvocationEntryBci) { | |
| 322 reset_counter_for_back_branch_event(method); | |
| 323 return NULL; | |
| 324 } | |
| 325 } | |
| 326 } | |
| 327 if (bci == InvocationEntryBci) { | |
| 328 // when code cache is full, compilation gets switched off, UseCompiler | |
| 329 // is set to false | |
| 330 if (!method->has_compiled_code() && UseCompiler) { | |
| 331 method_invocation_event(method, CHECK_NULL); | |
| 332 } else { | |
| 333 // Force counter overflow on method entry, even if no compilation | |
| 334 // happened. (The method_invocation_event call does this also.) | |
| 335 reset_counter_for_invocation_event(method); | |
| 336 } | |
| 337 // compilation at an invocation overflow no longer goes and retries test for | |
| 338 // compiled method. We always run the loser of the race as interpreted. | |
| 339 // so return NULL | |
| 340 return NULL; | |
| 341 } else { | |
| 342 // counter overflow in a loop => try to do on-stack-replacement | |
| 343 nmethod* osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true); | |
| 344 NOT_PRODUCT(trace_osr_request(method, osr_nm, bci)); | |
| 345 // when code cache is full, we should not compile any more... | |
| 346 if (osr_nm == NULL && UseCompiler) { | |
| 347 method_back_branch_event(method, bci, CHECK_NULL); | |
| 348 osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true); | |
| 349 } | |
| 350 if (osr_nm == NULL) { | |
| 351 reset_counter_for_back_branch_event(method); | |
| 352 return NULL; | |
| 353 } | |
| 354 return osr_nm; | |
| 355 } | |
| 356 return NULL; | |
| 357 } | |
| 358 | |
| 359 #ifndef PRODUCT | |
| 360 void NonTieredCompPolicy::trace_frequency_counter_overflow(methodHandle m, int branch_bci, int bci) { | |
| 361 if (TraceInvocationCounterOverflow) { | |
| 362 InvocationCounter* ic = m->invocation_counter(); | |
| 363 InvocationCounter* bc = m->backedge_counter(); | |
| 364 ResourceMark rm; | |
| 365 const char* msg = | |
| 366 bci == InvocationEntryBci | |
| 367 ? "comp-policy cntr ovfl @ %d in entry of " | |
| 368 : "comp-policy cntr ovfl @ %d in loop of "; | |
| 369 tty->print(msg, bci); | |
| 370 m->print_value(); | |
| 371 tty->cr(); | |
| 372 ic->print(); | |
| 373 bc->print(); | |
| 374 if (ProfileInterpreter) { | |
| 375 if (bci != InvocationEntryBci) { | |
| 376 methodDataOop mdo = m->method_data(); | |
| 377 if (mdo != NULL) { | |
| 378 int count = mdo->bci_to_data(branch_bci)->as_JumpData()->taken(); | |
| 379 tty->print_cr("back branch count = %d", count); | |
| 380 } | |
| 381 } | |
| 382 } | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 void NonTieredCompPolicy::trace_osr_request(methodHandle method, nmethod* osr, int bci) { | |
| 387 if (TraceOnStackReplacement) { | |
| 388 ResourceMark rm; | |
| 389 tty->print(osr != NULL ? "Reused OSR entry for " : "Requesting OSR entry for "); | |
| 390 method->print_short_name(tty); | |
| 391 tty->print_cr(" at bci %d", bci); | |
| 392 } | |
| 393 } | |
| 394 #endif // !PRODUCT | |
| 395 | |
| 0 | 396 // SimpleCompPolicy - compile current method |
| 397 | |
| 398 void SimpleCompPolicy::method_invocation_event( methodHandle m, TRAPS) { | |
| 399 int hot_count = m->invocation_count(); | |
| 400 reset_counter_for_invocation_event(m); | |
| 401 const char* comment = "count"; | |
| 402 | |
| 1783 | 403 if (is_compilation_enabled() && can_be_compiled(m)) { |
| 0 | 404 nmethod* nm = m->code(); |
| 405 if (nm == NULL ) { | |
| 406 const char* comment = "count"; | |
| 1783 | 407 CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier, |
| 0 | 408 m, hot_count, comment, CHECK); |
| 409 } | |
| 410 } | |
| 411 } | |
| 412 | |
| 1783 | 413 void SimpleCompPolicy::method_back_branch_event(methodHandle m, int bci, TRAPS) { |
| 0 | 414 int hot_count = m->backedge_count(); |
| 415 const char* comment = "backedge_count"; | |
| 416 | |
| 1783 | 417 if (is_compilation_enabled() && !m->is_not_osr_compilable() && can_be_compiled(m)) { |
| 418 CompileBroker::compile_method(m, bci, CompLevel_highest_tier, | |
| 419 m, hot_count, comment, CHECK); | |
| 420 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true));) | |
| 0 | 421 } |
| 422 } | |
| 423 // StackWalkCompPolicy - walk up stack to find a suitable method to compile | |
| 424 | |
| 425 #ifdef COMPILER2 | |
| 426 const char* StackWalkCompPolicy::_msg = NULL; | |
| 427 | |
| 428 | |
| 429 // Consider m for compilation | |
| 430 void StackWalkCompPolicy::method_invocation_event(methodHandle m, TRAPS) { | |
| 431 int hot_count = m->invocation_count(); | |
| 432 reset_counter_for_invocation_event(m); | |
| 433 const char* comment = "count"; | |
| 434 | |
| 1783 | 435 if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(m)) { |
| 0 | 436 ResourceMark rm(THREAD); |
| 437 JavaThread *thread = (JavaThread*)THREAD; | |
| 438 frame fr = thread->last_frame(); | |
| 439 assert(fr.is_interpreted_frame(), "must be interpreted"); | |
| 440 assert(fr.interpreter_frame_method() == m(), "bad method"); | |
| 441 | |
| 442 if (TraceCompilationPolicy) { | |
| 443 tty->print("method invocation trigger: "); | |
| 444 m->print_short_name(tty); | |
| 445 tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)m(), m->code_size()); | |
| 446 } | |
| 447 RegisterMap reg_map(thread, false); | |
| 448 javaVFrame* triggerVF = thread->last_java_vframe(®_map); | |
| 449 // triggerVF is the frame that triggered its counter | |
| 450 RFrame* first = new InterpretedRFrame(triggerVF->fr(), thread, m); | |
| 451 | |
| 452 if (first->top_method()->code() != NULL) { | |
| 453 // called obsolete method/nmethod -- no need to recompile | |
| 454 if (TraceCompilationPolicy) tty->print_cr(" --> " INTPTR_FORMAT, first->top_method()->code()); | |
| 455 } else { | |
| 456 if (TimeCompilationPolicy) accumulated_time()->start(); | |
| 457 GrowableArray<RFrame*>* stack = new GrowableArray<RFrame*>(50); | |
| 458 stack->push(first); | |
| 459 RFrame* top = findTopInlinableFrame(stack); | |
| 460 if (TimeCompilationPolicy) accumulated_time()->stop(); | |
| 461 assert(top != NULL, "findTopInlinableFrame returned null"); | |
| 462 if (TraceCompilationPolicy) top->print(); | |
| 1783 | 463 CompileBroker::compile_method(top->top_method(), InvocationEntryBci, CompLevel_highest_tier, |
| 0 | 464 m, hot_count, comment, CHECK); |
| 465 } | |
| 466 } | |
| 467 } | |
| 468 | |
| 1783 | 469 void StackWalkCompPolicy::method_back_branch_event(methodHandle m, int bci, TRAPS) { |
| 0 | 470 int hot_count = m->backedge_count(); |
| 471 const char* comment = "backedge_count"; | |
| 472 | |
| 1783 | 473 if (is_compilation_enabled() && !m->is_not_osr_compilable() && can_be_compiled(m)) { |
| 474 CompileBroker::compile_method(m, bci, CompLevel_highest_tier, m, hot_count, comment, CHECK); | |
| 0 | 475 |
| 1783 | 476 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true));) |
| 0 | 477 } |
| 478 } | |
| 479 | |
| 480 RFrame* StackWalkCompPolicy::findTopInlinableFrame(GrowableArray<RFrame*>* stack) { | |
| 481 // go up the stack until finding a frame that (probably) won't be inlined | |
| 482 // into its caller | |
| 483 RFrame* current = stack->at(0); // current choice for stopping | |
| 484 assert( current && !current->is_compiled(), "" ); | |
| 485 const char* msg = NULL; | |
| 486 | |
| 487 while (1) { | |
| 488 | |
| 489 // before going up the stack further, check if doing so would get us into | |
| 490 // compiled code | |
| 491 RFrame* next = senderOf(current, stack); | |
| 492 if( !next ) // No next frame up the stack? | |
| 493 break; // Then compile with current frame | |
| 494 | |
| 495 methodHandle m = current->top_method(); | |
| 496 methodHandle next_m = next->top_method(); | |
| 497 | |
| 498 if (TraceCompilationPolicy && Verbose) { | |
| 499 tty->print("[caller: "); | |
| 500 next_m->print_short_name(tty); | |
| 501 tty->print("] "); | |
| 502 } | |
| 503 | |
| 504 if( !Inline ) { // Inlining turned off | |
| 505 msg = "Inlining turned off"; | |
| 506 break; | |
| 507 } | |
| 508 if (next_m->is_not_compilable()) { // Did fail to compile this before/ | |
| 509 msg = "caller not compilable"; | |
| 510 break; | |
| 511 } | |
| 512 if (next->num() > MaxRecompilationSearchLength) { | |
| 513 // don't go up too high when searching for recompilees | |
| 514 msg = "don't go up any further: > MaxRecompilationSearchLength"; | |
| 515 break; | |
| 516 } | |
| 517 if (next->distance() > MaxInterpretedSearchLength) { | |
| 518 // don't go up too high when searching for recompilees | |
| 519 msg = "don't go up any further: next > MaxInterpretedSearchLength"; | |
| 520 break; | |
| 521 } | |
| 522 // Compiled frame above already decided not to inline; | |
| 523 // do not recompile him. | |
| 524 if (next->is_compiled()) { | |
| 525 msg = "not going up into optimized code"; | |
| 526 break; | |
| 527 } | |
| 528 | |
| 529 // Interpreted frame above us was already compiled. Do not force | |
| 530 // a recompile, although if the frame above us runs long enough an | |
| 531 // OSR might still happen. | |
| 532 if( current->is_interpreted() && next_m->has_compiled_code() ) { | |
| 533 msg = "not going up -- already compiled caller"; | |
| 534 break; | |
| 535 } | |
| 536 | |
| 537 // Compute how frequent this call site is. We have current method 'm'. | |
| 538 // We know next method 'next_m' is interpreted. Find the call site and | |
| 539 // check the various invocation counts. | |
| 540 int invcnt = 0; // Caller counts | |
| 541 if (ProfileInterpreter) { | |
| 542 invcnt = next_m->interpreter_invocation_count(); | |
| 543 } | |
| 544 int cnt = 0; // Call site counts | |
| 545 if (ProfileInterpreter && next_m->method_data() != NULL) { | |
| 546 ResourceMark rm; | |
| 547 int bci = next->top_vframe()->bci(); | |
| 548 ProfileData* data = next_m->method_data()->bci_to_data(bci); | |
| 549 if (data != NULL && data->is_CounterData()) | |
| 550 cnt = data->as_CounterData()->count(); | |
| 551 } | |
| 552 | |
| 553 // Caller counts / call-site counts; i.e. is this call site | |
| 554 // a hot call site for method next_m? | |
| 555 int freq = (invcnt) ? cnt/invcnt : cnt; | |
| 556 | |
| 557 // Check size and frequency limits | |
| 558 if ((msg = shouldInline(m, freq, cnt)) != NULL) { | |
| 559 break; | |
| 560 } | |
| 561 // Check inlining negative tests | |
| 562 if ((msg = shouldNotInline(m)) != NULL) { | |
| 563 break; | |
| 564 } | |
| 565 | |
| 566 | |
| 567 // If the caller method is too big or something then we do not want to | |
| 568 // compile it just to inline a method | |
| 1783 | 569 if (!can_be_compiled(next_m)) { |
| 0 | 570 msg = "caller cannot be compiled"; |
| 571 break; | |
| 572 } | |
| 573 | |
| 574 if( next_m->name() == vmSymbols::class_initializer_name() ) { | |
| 575 msg = "do not compile class initializer (OSR ok)"; | |
| 576 break; | |
| 577 } | |
| 578 | |
| 579 if (TraceCompilationPolicy && Verbose) { | |
| 580 tty->print("\n\t check caller: "); | |
| 581 next_m->print_short_name(tty); | |
| 582 tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)next_m(), next_m->code_size()); | |
| 583 } | |
| 584 | |
| 585 current = next; | |
| 586 } | |
| 587 | |
| 588 assert( !current || !current->is_compiled(), "" ); | |
| 589 | |
| 590 if (TraceCompilationPolicy && msg) tty->print("(%s)\n", msg); | |
| 591 | |
| 592 return current; | |
| 593 } | |
| 594 | |
| 595 RFrame* StackWalkCompPolicy::senderOf(RFrame* rf, GrowableArray<RFrame*>* stack) { | |
| 596 RFrame* sender = rf->caller(); | |
| 597 if (sender && sender->num() == stack->length()) stack->push(sender); | |
| 598 return sender; | |
| 599 } | |
| 600 | |
| 601 | |
| 602 const char* StackWalkCompPolicy::shouldInline(methodHandle m, float freq, int cnt) { | |
| 603 // Allows targeted inlining | |
| 604 // positive filter: should send be inlined? returns NULL (--> yes) | |
| 605 // or rejection msg | |
| 606 int max_size = MaxInlineSize; | |
| 607 int cost = m->code_size(); | |
| 608 | |
| 609 // Check for too many throws (and not too huge) | |
| 610 if (m->interpreter_throwout_count() > InlineThrowCount && cost < InlineThrowMaxSize ) { | |
| 611 return NULL; | |
| 612 } | |
| 613 | |
| 614 // bump the max size if the call is frequent | |
| 615 if ((freq >= InlineFrequencyRatio) || (cnt >= InlineFrequencyCount)) { | |
| 616 if (TraceFrequencyInlining) { | |
| 617 tty->print("(Inlined frequent method)\n"); | |
| 618 m->print(); | |
| 619 } | |
| 620 max_size = FreqInlineSize; | |
| 621 } | |
| 622 if (cost > max_size) { | |
| 623 return (_msg = "too big"); | |
| 624 } | |
| 625 return NULL; | |
| 626 } | |
| 627 | |
| 628 | |
| 629 const char* StackWalkCompPolicy::shouldNotInline(methodHandle m) { | |
| 630 // negative filter: should send NOT be inlined? returns NULL (--> inline) or rejection msg | |
| 631 if (m->is_abstract()) return (_msg = "abstract method"); | |
| 632 // note: we allow ik->is_abstract() | |
| 633 if (!instanceKlass::cast(m->method_holder())->is_initialized()) return (_msg = "method holder not initialized"); | |
| 634 if (m->is_native()) return (_msg = "native method"); | |
| 635 nmethod* m_code = m->code(); | |
| 1748 | 636 if (m_code != NULL && m_code->code_size() > InlineSmallCode) |
| 0 | 637 return (_msg = "already compiled into a big method"); |
| 638 | |
| 639 // use frequency-based objections only for non-trivial methods | |
| 640 if (m->code_size() <= MaxTrivialSize) return NULL; | |
| 641 if (UseInterpreter) { // don't use counts with -Xcomp | |
| 642 if ((m->code() == NULL) && m->was_never_executed()) return (_msg = "never executed"); | |
| 643 if (!m->was_executed_more_than(MIN2(MinInliningThreshold, CompileThreshold >> 1))) return (_msg = "executed < MinInliningThreshold times"); | |
| 644 } | |
| 645 if (methodOopDesc::has_unloaded_classes_in_signature(m, JavaThread::current())) return (_msg = "unloaded signature classes"); | |
| 646 | |
| 647 return NULL; | |
| 648 } | |
| 649 | |
| 650 | |
| 651 | |
| 652 #endif // COMPILER2 |