Mercurial > hg > truffle
annotate src/share/vm/runtime/compilationPolicy.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 89e4d67fdd2a |
| children | 3ce140f4f2c9 |
| 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; |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
83 case 4: |
|
8151
b8f261ba79c6
Minimize diff to plain HotSpot version.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
7684
diff
changeset
|
84 #ifdef GRAALVM |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
85 CompilationPolicy::set_policy(new GraalCompPolicy()); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
86 #else |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
87 Unimplemented(); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
88 #endif |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
89 break; |
| 0 | 90 default: |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
91 fatal("CompilationPolicyChoice must be in the range: [0-4]"); |
| 0 | 92 } |
| 1783 | 93 CompilationPolicy::policy()->initialize(); |
| 0 | 94 } |
| 95 | |
| 96 void CompilationPolicy::completed_vm_startup() { | |
| 97 if (TraceCompilationPolicy) { | |
| 98 tty->print("CompilationPolicy: completed vm startup.\n"); | |
| 99 } | |
| 100 _in_vm_startup = false; | |
| 101 } | |
| 102 | |
| 103 // Returns true if m must be compiled before executing it | |
| 104 // This is intended to force compiles for methods (usually for | |
| 105 // debugging) that would otherwise be interpreted for some reason. | |
| 1783 | 106 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
|
107 // Don't allow Xcomp to cause compiles in replay mode |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
108 if (ReplayCompiles) return false; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
109 |
| 0 | 110 if (m->has_compiled_code()) return false; // already compiled |
| 1783 | 111 if (!can_be_compiled(m, comp_level)) return false; |
| 0 | 112 |
| 113 return !UseInterpreter || // must compile all methods | |
| 1202 | 114 (UseCompiler && AlwaysCompileLoopMethods && m->has_loops() && CompileBroker::should_compile_new_jobs()); // eagerly compile loop methods |
| 0 | 115 } |
| 116 | |
| 117 // Returns true if m is allowed to be compiled | |
| 1783 | 118 bool CompilationPolicy::can_be_compiled(methodHandle m, int comp_level) { |
| 0 | 119 if (m->is_abstract()) return false; |
| 120 if (DontCompileHugeMethods && m->code_size() > HugeMethodLimit) return false; | |
| 121 | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
122 // 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
|
123 // 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
|
124 // 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
|
125 // 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
|
126 // 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
|
127 // modes. |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
128 if (!AbstractInterpreter::can_be_compiled(m)) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
129 return false; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
130 } |
| 1783 | 131 if (comp_level == CompLevel_all) { |
| 132 return !m->is_not_compilable(CompLevel_simple) && !m->is_not_compilable(CompLevel_full_optimization); | |
|
9080
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
6972
diff
changeset
|
133 } else if (is_compile(comp_level)) { |
| 1783 | 134 return !m->is_not_compilable(comp_level); |
| 135 } | |
|
9080
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
6972
diff
changeset
|
136 return false; |
| 1783 | 137 } |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
0
diff
changeset
|
138 |
| 1783 | 139 bool CompilationPolicy::is_compilation_enabled() { |
| 140 // NOTE: CompileBroker::should_compile_new_jobs() checks for UseCompiler | |
| 141 return !delay_compilation_during_startup() && CompileBroker::should_compile_new_jobs(); | |
| 0 | 142 } |
| 143 | |
| 144 #ifndef PRODUCT | |
| 145 void CompilationPolicy::print_time() { | |
| 146 tty->print_cr ("Accumulated compilationPolicy times:"); | |
| 147 tty->print_cr ("---------------------------"); | |
| 148 tty->print_cr (" Total: %3.3f sec.", _accumulated_time.seconds()); | |
| 149 } | |
| 150 | |
| 1783 | 151 void NonTieredCompPolicy::trace_osr_completion(nmethod* osr_nm) { |
| 0 | 152 if (TraceOnStackReplacement) { |
| 153 if (osr_nm == NULL) tty->print_cr("compilation failed"); | |
| 154 else tty->print_cr("nmethod " INTPTR_FORMAT, osr_nm); | |
| 155 } | |
| 156 } | |
| 157 #endif // !PRODUCT | |
| 158 | |
| 1783 | 159 void NonTieredCompPolicy::initialize() { |
| 160 // Setup the compiler thread numbers | |
| 161 if (CICompilerCountPerCPU) { | |
| 162 // Example: if CICompilerCountPerCPU is true, then we get | |
| 163 // max(log2(8)-1,1) = 2 compiler threads on an 8-way machine. | |
| 164 // May help big-app startup time. | |
| 165 _compiler_count = MAX2(log2_intptr(os::active_processor_count())-1,1); | |
| 166 } else { | |
| 167 _compiler_count = CICompilerCount; | |
| 168 } | |
| 169 } | |
| 170 | |
|
1821
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
171 // 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
|
172 // compiler_count() behaves the following way: |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
173 // - 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
|
174 // 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
|
175 // statements. |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
176 // - 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
|
177 // (server build without TIERED defined). |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
178 // - 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
|
179 // the c2 level. |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
180 // - if neither is defined - always return zero. |
| 1783 | 181 int NonTieredCompPolicy::compiler_count(CompLevel comp_level) { |
|
1821
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
182 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
|
183 #ifdef COMPILER2 |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
184 if (is_c2_compile(comp_level)) { |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
185 return _compiler_count; |
|
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; |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
188 } |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
189 #endif |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
190 |
| 1783 | 191 #ifdef COMPILER1 |
| 192 if (is_c1_compile(comp_level)) { | |
| 193 return _compiler_count; | |
|
1821
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
194 } else { |
|
df015ec64052
6987115: Non-tiered compilation policy creates unnecessary C1 threads
iveresov
parents:
1783
diff
changeset
|
195 return 0; |
| 1783 | 196 } |
| 197 #endif | |
| 198 | |
| 199 return 0; | |
| 200 } | |
| 201 | |
| 202 void NonTieredCompPolicy::reset_counter_for_invocation_event(methodHandle m) { | |
| 0 | 203 // Make sure invocation and backedge counter doesn't overflow again right away |
| 204 // as would be the case for native methods. | |
| 205 | |
| 206 // BUT also make sure the method doesn't look like it was never executed. | |
| 207 // Set carry bit and reduce counter's value to min(count, CompileThreshold/2). | |
| 208 m->invocation_counter()->set_carry(); | |
| 209 m->backedge_counter()->set_carry(); | |
| 210 | |
| 211 assert(!m->was_never_executed(), "don't reset to 0 -- could be mistaken for never-executed"); | |
| 212 } | |
| 213 | |
| 1783 | 214 void NonTieredCompPolicy::reset_counter_for_back_branch_event(methodHandle m) { |
| 0 | 215 // Delay next back-branch event but pump up invocation counter to triger |
| 216 // whole method compilation. | |
| 217 InvocationCounter* i = m->invocation_counter(); | |
| 218 InvocationCounter* b = m->backedge_counter(); | |
| 219 | |
| 220 // Don't set invocation_counter's value too low otherwise the method will | |
| 221 // look like immature (ic < ~5300) which prevents the inlining based on | |
| 222 // the type profiling. | |
| 223 i->set(i->state(), CompileThreshold); | |
| 224 // Don't reset counter too low - it is used to check if OSR method is ready. | |
| 225 b->set(b->state(), CompileThreshold / 2); | |
| 226 } | |
| 227 | |
| 1783 | 228 // |
| 229 // CounterDecay | |
| 230 // | |
| 231 // Interates through invocation counters and decrements them. This | |
| 232 // is done at each safepoint. | |
| 233 // | |
| 234 class CounterDecay : public AllStatic { | |
| 235 static jlong _last_timestamp; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
236 static void do_method(Method* m) { |
| 1783 | 237 m->invocation_counter()->decay(); |
| 238 } | |
| 239 public: | |
| 240 static void decay(); | |
| 241 static bool is_decay_needed() { | |
| 242 return (os::javaTimeMillis() - _last_timestamp) > CounterDecayMinIntervalLength; | |
| 243 } | |
| 244 }; | |
| 245 | |
| 246 jlong CounterDecay::_last_timestamp = 0; | |
| 247 | |
| 248 void CounterDecay::decay() { | |
| 249 _last_timestamp = os::javaTimeMillis(); | |
| 250 | |
| 251 // This operation is going to be performed only at the end of a safepoint | |
| 252 // and hence GC's will not be going on, all Java mutators are suspended | |
| 253 // at this point and hence SystemDictionary_lock is also not needed. | |
| 254 assert(SafepointSynchronize::is_at_safepoint(), "can only be executed at a safepoint"); | |
| 255 int nclasses = SystemDictionary::number_of_classes(); | |
| 256 double classes_per_tick = nclasses * (CounterDecayMinIntervalLength * 1e-3 / | |
| 257 CounterHalfLifeTime); | |
| 258 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
|
259 Klass* k = SystemDictionary::try_get_next_class(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
260 if (k != NULL && k->oop_is_instance()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
261 InstanceKlass::cast(k)->methods_do(do_method); |
| 1783 | 262 } |
| 263 } | |
| 264 } | |
| 265 | |
| 266 // Called at the end of the safepoint | |
| 267 void NonTieredCompPolicy::do_safepoint_work() { | |
| 268 if(UseCounterDecay && CounterDecay::is_decay_needed()) { | |
| 269 CounterDecay::decay(); | |
| 270 } | |
| 271 } | |
| 272 | |
| 273 void NonTieredCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) { | |
| 274 ScopeDesc* sd = trap_scope; | |
| 275 for (; !sd->is_top(); sd = sd->sender()) { | |
| 276 // Reset ICs of inlined methods, since they can trigger compilations also. | |
| 277 sd->method()->invocation_counter()->reset(); | |
| 278 } | |
| 279 InvocationCounter* c = sd->method()->invocation_counter(); | |
| 280 if (is_osr) { | |
| 281 // It was an OSR method, so bump the count higher. | |
| 282 c->set(c->state(), CompileThreshold); | |
| 283 } else { | |
| 284 c->reset(); | |
| 285 } | |
| 286 sd->method()->backedge_counter()->reset(); | |
| 287 } | |
| 288 | |
| 289 // This method can be called by any component of the runtime to notify the policy | |
| 290 // 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
|
291 void NonTieredCompPolicy::delay_compilation(Method* method) { |
| 1783 | 292 method->invocation_counter()->decay(); |
| 293 method->backedge_counter()->decay(); | |
| 294 } | |
| 295 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
296 void NonTieredCompPolicy::disable_compilation(Method* method) { |
| 1783 | 297 method->invocation_counter()->set_state(InvocationCounter::wait_for_nothing); |
| 298 method->backedge_counter()->set_state(InvocationCounter::wait_for_nothing); | |
| 299 } | |
| 300 | |
| 301 CompileTask* NonTieredCompPolicy::select_task(CompileQueue* compile_queue) { | |
| 302 return compile_queue->first(); | |
| 303 } | |
| 304 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
305 bool NonTieredCompPolicy::is_mature(Method* method) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
306 MethodData* mdo = method->method_data(); |
| 1783 | 307 assert(mdo != NULL, "Should be"); |
| 308 uint current = mdo->mileage_of(method); | |
| 309 uint initial = mdo->creation_mileage(); | |
| 310 if (current < initial) | |
| 311 return true; // some sort of overflow | |
| 312 uint target; | |
| 313 if (ProfileMaturityPercentage <= 0) | |
| 314 target = (uint) -ProfileMaturityPercentage; // absolute value | |
| 315 else | |
| 316 target = (uint)( (ProfileMaturityPercentage * CompileThreshold) / 100 ); | |
| 317 return (current >= initial + target); | |
| 318 } | |
| 319 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
320 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
|
321 int bci, CompLevel comp_level, nmethod* nm, JavaThread* thread) { |
| 1783 | 322 assert(comp_level == CompLevel_none, "This should be only called from the interpreter"); |
| 323 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
|
324 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
|
325 // 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
|
326 // 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
|
327 // 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
|
328 // 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
|
329 // 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
|
330 // interpreted-only threads. |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
331 if (bci != InvocationEntryBci) { |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
332 reset_counter_for_back_branch_event(method); |
|
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
333 return NULL; |
| 1783 | 334 } |
| 335 } | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
336 if (CompileTheWorld || ReplayCompiles) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
337 // Don't trigger other compiles in testing mode |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
338 if (bci == InvocationEntryBci) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
339 reset_counter_for_invocation_event(method); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
340 } else { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
341 reset_counter_for_back_branch_event(method); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
342 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
343 return NULL; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
344 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
345 |
| 1783 | 346 if (bci == InvocationEntryBci) { |
| 347 // when code cache is full, compilation gets switched off, UseCompiler | |
| 348 // is set to false | |
| 349 if (!method->has_compiled_code() && UseCompiler) { | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
350 method_invocation_event(method, thread); |
| 1783 | 351 } else { |
| 352 // Force counter overflow on method entry, even if no compilation | |
| 353 // happened. (The method_invocation_event call does this also.) | |
| 354 reset_counter_for_invocation_event(method); | |
| 355 } | |
| 356 // compilation at an invocation overflow no longer goes and retries test for | |
| 357 // compiled method. We always run the loser of the race as interpreted. | |
| 358 // so return NULL | |
| 359 return NULL; | |
| 360 } else { | |
| 361 // counter overflow in a loop => try to do on-stack-replacement | |
| 362 nmethod* osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true); | |
| 363 NOT_PRODUCT(trace_osr_request(method, osr_nm, bci)); | |
| 364 // when code cache is full, we should not compile any more... | |
| 365 if (osr_nm == NULL && UseCompiler) { | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
366 method_back_branch_event(method, bci, thread); |
| 1783 | 367 osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true); |
| 368 } | |
| 369 if (osr_nm == NULL) { | |
| 370 reset_counter_for_back_branch_event(method); | |
| 371 return NULL; | |
| 372 } | |
| 373 return osr_nm; | |
| 374 } | |
| 375 return NULL; | |
| 376 } | |
| 377 | |
| 378 #ifndef PRODUCT | |
| 379 void NonTieredCompPolicy::trace_frequency_counter_overflow(methodHandle m, int branch_bci, int bci) { | |
| 380 if (TraceInvocationCounterOverflow) { | |
| 381 InvocationCounter* ic = m->invocation_counter(); | |
| 382 InvocationCounter* bc = m->backedge_counter(); | |
| 383 ResourceMark rm; | |
| 384 const char* msg = | |
| 385 bci == InvocationEntryBci | |
| 386 ? "comp-policy cntr ovfl @ %d in entry of " | |
| 387 : "comp-policy cntr ovfl @ %d in loop of "; | |
| 388 tty->print(msg, bci); | |
| 389 m->print_value(); | |
| 390 tty->cr(); | |
| 391 ic->print(); | |
| 392 bc->print(); | |
| 393 if (ProfileInterpreter) { | |
| 394 if (bci != InvocationEntryBci) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
395 MethodData* mdo = m->method_data(); |
| 1783 | 396 if (mdo != NULL) { |
| 397 int count = mdo->bci_to_data(branch_bci)->as_JumpData()->taken(); | |
| 398 tty->print_cr("back branch count = %d", count); | |
| 399 } | |
| 400 } | |
| 401 } | |
| 402 } | |
| 403 } | |
| 404 | |
| 405 void NonTieredCompPolicy::trace_osr_request(methodHandle method, nmethod* osr, int bci) { | |
| 406 if (TraceOnStackReplacement) { | |
| 407 ResourceMark rm; | |
| 408 tty->print(osr != NULL ? "Reused OSR entry for " : "Requesting OSR entry for "); | |
| 409 method->print_short_name(tty); | |
| 410 tty->print_cr(" at bci %d", bci); | |
| 411 } | |
| 412 } | |
| 413 #endif // !PRODUCT | |
| 414 | |
| 0 | 415 // SimpleCompPolicy - compile current method |
| 416 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
417 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
|
418 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
419 const int hot_count = m->invocation_count(); |
| 0 | 420 reset_counter_for_invocation_event(m); |
| 421 const char* comment = "count"; | |
| 422 | |
| 1783 | 423 if (is_compilation_enabled() && can_be_compiled(m)) { |
| 0 | 424 nmethod* nm = m->code(); |
| 425 if (nm == NULL ) { | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
426 CompileBroker::compile_method(m, InvocationEntryBci, comp_level, m, hot_count, comment, thread); |
| 0 | 427 } |
| 428 } | |
| 429 } | |
| 430 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
431 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
|
432 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
433 const int hot_count = m->backedge_count(); |
| 0 | 434 const char* comment = "backedge_count"; |
| 435 | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
436 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
|
437 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
|
438 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));) |
| 0 | 439 } |
| 440 } | |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
441 |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
442 // GraalCompPolicy - compile current method |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
443 |
|
7154
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
7125
diff
changeset
|
444 #ifdef GRAALVM |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
445 |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
446 void GraalCompPolicy::method_invocation_event(methodHandle m, JavaThread* thread) { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
447 int hot_count = m->invocation_count(); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
448 jlong hot_time = m->graal_invocation_time(); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
449 reset_counter_for_invocation_event(m); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
450 |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
451 if (is_compilation_enabled() && can_be_compiled(m)) { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
452 nmethod* nm = m->code(); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
453 if (nm == NULL) { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
454 if (hot_count > 1) { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
455 jlong current_time = os::javaTimeNanos(); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
456 int time_per_call = (int) ((current_time - hot_time) / hot_count); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
457 m->set_graal_invocation_time(current_time); |
|
5263
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
458 if (UseNewCode) { |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
459 if (m->queued_for_compilation()) { |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
460 if (time_per_call < (m->graal_priority() / 5)) { |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
461 m->set_graal_priority(time_per_call); |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
462 m->clear_queued_for_compilation(); |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
463 } |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
464 } else { |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
465 if (time_per_call < m->graal_priority()) { |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
466 m->set_graal_priority(time_per_call); |
|
d87155082c4d
guard all compilation queue accesses, to avoid deadlocks
Lukas Stadler <lukas.stadler@jku.at>
parents:
5176
diff
changeset
|
467 } |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
468 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
469 } else { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
470 if (time_per_call < m->graal_priority()) { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
471 m->set_graal_priority(time_per_call); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
472 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
473 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
474 } |
|
7062
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
475 |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
476 if (!m->queued_for_compilation()) { |
|
7062
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
477 if (TraceCompilationPolicy) { |
|
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
478 tty->print("method invocation trigger: "); |
|
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
479 m->print_short_name(tty); |
|
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
480 tty->print_cr(" ( interpreted " INTPTR_FORMAT ", size=%d, hotCount=%d, hotTime=" UINT64_FORMAT " ) ", (address)m(), m->code_size(), hot_count, hot_time); |
|
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
481 } |
|
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
482 |
|
8c5333c80cfd
increased CompileThreshold to increase reliability of profiling information
Christian Haeubl <haeubl@ssw.jku.at>
parents:
6674
diff
changeset
|
483 assert(m->is_native() || m->method_data() != NULL, "do not compile code methods"); |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
484 CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier, m, hot_count, "count", thread); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
485 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
486 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
487 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
488 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
489 |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
490 void GraalCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) { |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
491 int hot_count = m->backedge_count(); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
492 const char* comment = "backedge_count"; |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
493 |
|
7684
bbf97d6688d3
cleanup for the inlining policies
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7226
diff
changeset
|
494 if (is_compilation_enabled() && !m->is_not_osr_compilable() && can_be_compiled(m) && !m->queued_for_compilation() && m->code() == NULL) { |
|
7224
fb16d8681ddc
bugfixes for compiler intrinsics
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7125
diff
changeset
|
495 if (TraceCompilationPolicy) { |
|
fb16d8681ddc
bugfixes for compiler intrinsics
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7125
diff
changeset
|
496 tty->print("backedge invocation trigger: "); |
|
fb16d8681ddc
bugfixes for compiler intrinsics
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7125
diff
changeset
|
497 m->print_short_name(tty); |
|
fb16d8681ddc
bugfixes for compiler intrinsics
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7125
diff
changeset
|
498 tty->print_cr(" ( interpreted " INTPTR_FORMAT ", size=%d, hotCount=%d ) ", (address)m(), m->code_size(), hot_count); |
|
fb16d8681ddc
bugfixes for compiler intrinsics
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7125
diff
changeset
|
499 } |
|
fb16d8681ddc
bugfixes for compiler intrinsics
Christian Haeubl <haeubl@ssw.jku.at>
parents:
7125
diff
changeset
|
500 |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
501 CompileBroker::compile_method(m, bci, CompLevel_highest_tier, |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
502 m, hot_count, comment, thread); |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
503 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true));) |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
504 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
505 } |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
506 |
|
7154
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
7125
diff
changeset
|
507 #endif // GRAALVM |
|
5176
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
508 |
|
af59b4dfc9e4
compilation queue changes:
Lukas Stadler <lukas.stadler@jku.at>
parents:
4977
diff
changeset
|
509 |
| 0 | 510 // StackWalkCompPolicy - walk up stack to find a suitable method to compile |
| 511 | |
| 512 #ifdef COMPILER2 | |
| 513 const char* StackWalkCompPolicy::_msg = NULL; | |
| 514 | |
| 515 | |
| 516 // Consider m for compilation | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
517 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
|
518 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
519 const int hot_count = m->invocation_count(); |
| 0 | 520 reset_counter_for_invocation_event(m); |
| 521 const char* comment = "count"; | |
| 522 | |
| 1783 | 523 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
|
524 ResourceMark rm(thread); |
| 0 | 525 frame fr = thread->last_frame(); |
| 526 assert(fr.is_interpreted_frame(), "must be interpreted"); | |
| 527 assert(fr.interpreter_frame_method() == m(), "bad method"); | |
| 528 | |
| 529 if (TraceCompilationPolicy) { | |
| 530 tty->print("method invocation trigger: "); | |
| 531 m->print_short_name(tty); | |
| 532 tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)m(), m->code_size()); | |
| 533 } | |
| 534 RegisterMap reg_map(thread, false); | |
| 535 javaVFrame* triggerVF = thread->last_java_vframe(®_map); | |
| 536 // triggerVF is the frame that triggered its counter | |
| 537 RFrame* first = new InterpretedRFrame(triggerVF->fr(), thread, m); | |
| 538 | |
| 539 if (first->top_method()->code() != NULL) { | |
| 540 // called obsolete method/nmethod -- no need to recompile | |
| 541 if (TraceCompilationPolicy) tty->print_cr(" --> " INTPTR_FORMAT, first->top_method()->code()); | |
| 542 } else { | |
| 543 if (TimeCompilationPolicy) accumulated_time()->start(); | |
| 544 GrowableArray<RFrame*>* stack = new GrowableArray<RFrame*>(50); | |
| 545 stack->push(first); | |
| 546 RFrame* top = findTopInlinableFrame(stack); | |
| 547 if (TimeCompilationPolicy) accumulated_time()->stop(); | |
| 548 assert(top != NULL, "findTopInlinableFrame returned null"); | |
| 549 if (TraceCompilationPolicy) top->print(); | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
550 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
|
551 m, hot_count, comment, thread); |
| 0 | 552 } |
| 553 } | |
| 554 } | |
| 555 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
3791
diff
changeset
|
556 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
|
557 const int comp_level = CompLevel_highest_tier; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
558 const int hot_count = m->backedge_count(); |
| 0 | 559 const char* comment = "backedge_count"; |
| 560 | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
561 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
|
562 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
|
563 NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));) |
| 0 | 564 } |
| 565 } | |
| 566 | |
| 567 RFrame* StackWalkCompPolicy::findTopInlinableFrame(GrowableArray<RFrame*>* stack) { | |
| 568 // go up the stack until finding a frame that (probably) won't be inlined | |
| 569 // into its caller | |
| 570 RFrame* current = stack->at(0); // current choice for stopping | |
| 571 assert( current && !current->is_compiled(), "" ); | |
| 572 const char* msg = NULL; | |
| 573 | |
| 574 while (1) { | |
| 575 | |
| 576 // before going up the stack further, check if doing so would get us into | |
| 577 // compiled code | |
| 578 RFrame* next = senderOf(current, stack); | |
| 579 if( !next ) // No next frame up the stack? | |
| 580 break; // Then compile with current frame | |
| 581 | |
| 582 methodHandle m = current->top_method(); | |
| 583 methodHandle next_m = next->top_method(); | |
| 584 | |
| 585 if (TraceCompilationPolicy && Verbose) { | |
| 586 tty->print("[caller: "); | |
| 587 next_m->print_short_name(tty); | |
| 588 tty->print("] "); | |
| 589 } | |
| 590 | |
| 591 if( !Inline ) { // Inlining turned off | |
| 592 msg = "Inlining turned off"; | |
| 593 break; | |
| 594 } | |
| 595 if (next_m->is_not_compilable()) { // Did fail to compile this before/ | |
| 596 msg = "caller not compilable"; | |
| 597 break; | |
| 598 } | |
| 599 if (next->num() > MaxRecompilationSearchLength) { | |
| 600 // don't go up too high when searching for recompilees | |
| 601 msg = "don't go up any further: > MaxRecompilationSearchLength"; | |
| 602 break; | |
| 603 } | |
| 604 if (next->distance() > MaxInterpretedSearchLength) { | |
| 605 // don't go up too high when searching for recompilees | |
| 606 msg = "don't go up any further: next > MaxInterpretedSearchLength"; | |
| 607 break; | |
| 608 } | |
| 609 // Compiled frame above already decided not to inline; | |
| 610 // do not recompile him. | |
| 611 if (next->is_compiled()) { | |
| 612 msg = "not going up into optimized code"; | |
| 613 break; | |
| 614 } | |
| 615 | |
| 616 // Interpreted frame above us was already compiled. Do not force | |
| 617 // a recompile, although if the frame above us runs long enough an | |
| 618 // OSR might still happen. | |
| 619 if( current->is_interpreted() && next_m->has_compiled_code() ) { | |
| 620 msg = "not going up -- already compiled caller"; | |
| 621 break; | |
| 622 } | |
| 623 | |
| 624 // Compute how frequent this call site is. We have current method 'm'. | |
| 625 // We know next method 'next_m' is interpreted. Find the call site and | |
| 626 // check the various invocation counts. | |
| 627 int invcnt = 0; // Caller counts | |
| 628 if (ProfileInterpreter) { | |
| 629 invcnt = next_m->interpreter_invocation_count(); | |
| 630 } | |
| 631 int cnt = 0; // Call site counts | |
| 632 if (ProfileInterpreter && next_m->method_data() != NULL) { | |
| 633 ResourceMark rm; | |
| 634 int bci = next->top_vframe()->bci(); | |
| 635 ProfileData* data = next_m->method_data()->bci_to_data(bci); | |
| 636 if (data != NULL && data->is_CounterData()) | |
| 637 cnt = data->as_CounterData()->count(); | |
| 638 } | |
| 639 | |
| 640 // Caller counts / call-site counts; i.e. is this call site | |
| 641 // a hot call site for method next_m? | |
| 642 int freq = (invcnt) ? cnt/invcnt : cnt; | |
| 643 | |
| 644 // Check size and frequency limits | |
| 645 if ((msg = shouldInline(m, freq, cnt)) != NULL) { | |
| 646 break; | |
| 647 } | |
| 648 // Check inlining negative tests | |
| 649 if ((msg = shouldNotInline(m)) != NULL) { | |
| 650 break; | |
| 651 } | |
| 652 | |
| 653 | |
| 654 // If the caller method is too big or something then we do not want to | |
| 655 // compile it just to inline a method | |
| 1783 | 656 if (!can_be_compiled(next_m)) { |
| 0 | 657 msg = "caller cannot be compiled"; |
| 658 break; | |
| 659 } | |
| 660 | |
| 661 if( next_m->name() == vmSymbols::class_initializer_name() ) { | |
| 662 msg = "do not compile class initializer (OSR ok)"; | |
| 663 break; | |
| 664 } | |
| 665 | |
| 666 if (TraceCompilationPolicy && Verbose) { | |
| 667 tty->print("\n\t check caller: "); | |
| 668 next_m->print_short_name(tty); | |
| 669 tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)next_m(), next_m->code_size()); | |
| 670 } | |
| 671 | |
| 672 current = next; | |
| 673 } | |
| 674 | |
| 675 assert( !current || !current->is_compiled(), "" ); | |
| 676 | |
| 677 if (TraceCompilationPolicy && msg) tty->print("(%s)\n", msg); | |
| 678 | |
| 679 return current; | |
| 680 } | |
| 681 | |
| 682 RFrame* StackWalkCompPolicy::senderOf(RFrame* rf, GrowableArray<RFrame*>* stack) { | |
| 683 RFrame* sender = rf->caller(); | |
| 684 if (sender && sender->num() == stack->length()) stack->push(sender); | |
| 685 return sender; | |
| 686 } | |
| 687 | |
| 688 | |
| 689 const char* StackWalkCompPolicy::shouldInline(methodHandle m, float freq, int cnt) { | |
| 690 // Allows targeted inlining | |
| 691 // positive filter: should send be inlined? returns NULL (--> yes) | |
| 692 // or rejection msg | |
| 693 int max_size = MaxInlineSize; | |
| 694 int cost = m->code_size(); | |
| 695 | |
| 696 // Check for too many throws (and not too huge) | |
| 697 if (m->interpreter_throwout_count() > InlineThrowCount && cost < InlineThrowMaxSize ) { | |
| 698 return NULL; | |
| 699 } | |
| 700 | |
| 701 // bump the max size if the call is frequent | |
| 702 if ((freq >= InlineFrequencyRatio) || (cnt >= InlineFrequencyCount)) { | |
| 703 if (TraceFrequencyInlining) { | |
| 704 tty->print("(Inlined frequent method)\n"); | |
| 705 m->print(); | |
| 706 } | |
| 707 max_size = FreqInlineSize; | |
| 708 } | |
| 709 if (cost > max_size) { | |
| 710 return (_msg = "too big"); | |
| 711 } | |
| 712 return NULL; | |
| 713 } | |
| 714 | |
| 715 | |
| 716 const char* StackWalkCompPolicy::shouldNotInline(methodHandle m) { | |
| 717 // negative filter: should send NOT be inlined? returns NULL (--> inline) or rejection msg | |
| 718 if (m->is_abstract()) return (_msg = "abstract method"); | |
| 719 // 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
|
720 if (!m->method_holder()->is_initialized()) return (_msg = "method holder not initialized"); |
| 0 | 721 if (m->is_native()) return (_msg = "native method"); |
| 722 nmethod* m_code = m->code(); | |
| 1748 | 723 if (m_code != NULL && m_code->code_size() > InlineSmallCode) |
| 0 | 724 return (_msg = "already compiled into a big method"); |
| 725 | |
| 726 // use frequency-based objections only for non-trivial methods | |
| 727 if (m->code_size() <= MaxTrivialSize) return NULL; | |
| 728 if (UseInterpreter) { // don't use counts with -Xcomp | |
| 729 if ((m->code() == NULL) && m->was_never_executed()) return (_msg = "never executed"); | |
| 730 if (!m->was_executed_more_than(MIN2(MinInliningThreshold, CompileThreshold >> 1))) return (_msg = "executed < MinInliningThreshold times"); | |
| 731 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
732 if (Method::has_unloaded_classes_in_signature(m, JavaThread::current())) return (_msg = "unloaded signature classes"); |
| 0 | 733 |
| 734 return NULL; | |
| 735 } | |
| 736 | |
| 737 | |
| 738 | |
| 739 #endif // COMPILER2 |