Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/simpleThresholdPolicy.cpp @ 3917:eca1193ca245
4965777: GC changes to support use of discovered field for pending references
Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose.
Reviewed-by: jcoomes, mchung, stefank
| author | ysr |
|---|---|
| date | Wed, 07 Sep 2011 13:55:42 -0700 |
| parents | 43f9d800f276 |
| children | 973293defacd |
| rev | line source |
|---|---|
| 1783 | 1 /* |
| 3358 | 2 * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved. |
| 1783 | 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 * | |
| 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| 20 * or visit www.oracle.com if you need additional information or have any | |
| 21 * questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "compiler/compileBroker.hpp" | |
| 27 #include "memory/resourceArea.hpp" | |
| 28 #include "runtime/arguments.hpp" | |
| 29 #include "runtime/simpleThresholdPolicy.hpp" | |
| 30 #include "runtime/simpleThresholdPolicy.inline.hpp" | |
| 2252 | 31 #include "code/scopeDesc.hpp" |
| 1783 | 32 |
| 33 // Print an event. | |
| 34 void SimpleThresholdPolicy::print_event(EventType type, methodHandle mh, methodHandle imh, | |
| 35 int bci, CompLevel level) { | |
| 36 bool inlinee_event = mh() != imh(); | |
| 37 | |
| 38 ttyLocker tty_lock; | |
| 39 tty->print("%lf: [", os::elapsedTime()); | |
| 40 | |
| 41 int invocation_count = mh->invocation_count(); | |
| 42 int backedge_count = mh->backedge_count(); | |
| 43 switch(type) { | |
| 44 case CALL: | |
| 45 tty->print("call"); | |
| 46 break; | |
| 47 case LOOP: | |
| 48 tty->print("loop"); | |
| 49 break; | |
| 50 case COMPILE: | |
| 51 tty->print("compile"); | |
| 2252 | 52 break; |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
53 case REMOVE_FROM_QUEUE: |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
54 tty->print("remove-from-queue"); |
| 2252 | 55 break; |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
56 case UPDATE_IN_QUEUE: |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
57 tty->print("update-in-queue"); |
| 2252 | 58 break; |
| 59 case REPROFILE: | |
| 60 tty->print("reprofile"); | |
| 61 break; | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
62 case MAKE_NOT_ENTRANT: |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
63 tty->print("make-not-entrant"); |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
64 break; |
| 2252 | 65 default: |
| 66 tty->print("unknown"); | |
| 1783 | 67 } |
| 68 | |
| 69 tty->print(" level: %d ", level); | |
| 70 | |
| 71 ResourceMark rm; | |
| 72 char *method_name = mh->name_and_sig_as_C_string(); | |
| 73 tty->print("[%s", method_name); | |
| 74 if (inlinee_event) { | |
| 75 char *inlinee_name = imh->name_and_sig_as_C_string(); | |
| 76 tty->print(" [%s]] ", inlinee_name); | |
| 77 } | |
| 78 else tty->print("] "); | |
| 79 tty->print("@%d queues: %d,%d", bci, CompileBroker::queue_size(CompLevel_full_profile), | |
| 80 CompileBroker::queue_size(CompLevel_full_optimization)); | |
| 81 | |
| 82 print_specific(type, mh, imh, bci, level); | |
| 83 | |
| 84 if (type != COMPILE) { | |
| 85 methodDataHandle mdh = mh->method_data(); | |
| 86 int mdo_invocations = 0, mdo_backedges = 0; | |
| 2252 | 87 int mdo_invocations_start = 0, mdo_backedges_start = 0; |
| 1783 | 88 if (mdh() != NULL) { |
| 89 mdo_invocations = mdh->invocation_count(); | |
| 90 mdo_backedges = mdh->backedge_count(); | |
| 2252 | 91 mdo_invocations_start = mdh->invocation_count_start(); |
| 92 mdo_backedges_start = mdh->backedge_count_start(); | |
| 1783 | 93 } |
| 2252 | 94 tty->print(" total: %d,%d mdo: %d(%d),%d(%d)", |
| 1783 | 95 invocation_count, backedge_count, |
| 2252 | 96 mdo_invocations, mdo_invocations_start, |
| 97 mdo_backedges, mdo_backedges_start); | |
| 1783 | 98 tty->print(" max levels: %d,%d", |
| 99 mh->highest_comp_level(), mh->highest_osr_comp_level()); | |
| 100 if (inlinee_event) { | |
| 101 tty->print(" inlinee max levels: %d,%d", imh->highest_comp_level(), imh->highest_osr_comp_level()); | |
| 102 } | |
| 103 tty->print(" compilable: "); | |
| 104 bool need_comma = false; | |
| 105 if (!mh->is_not_compilable(CompLevel_full_profile)) { | |
| 106 tty->print("c1"); | |
| 107 need_comma = true; | |
| 108 } | |
| 109 if (!mh->is_not_compilable(CompLevel_full_optimization)) { | |
| 110 if (need_comma) tty->print(", "); | |
| 111 tty->print("c2"); | |
| 112 need_comma = true; | |
| 113 } | |
| 114 if (!mh->is_not_osr_compilable()) { | |
| 115 if (need_comma) tty->print(", "); | |
| 116 tty->print("osr"); | |
| 117 } | |
| 118 tty->print(" status:"); | |
| 119 if (mh->queued_for_compilation()) { | |
| 120 tty->print(" in queue"); | |
| 121 } else tty->print(" idle"); | |
| 122 } | |
| 123 tty->print_cr("]"); | |
| 124 } | |
| 125 | |
| 126 void SimpleThresholdPolicy::initialize() { | |
| 127 if (FLAG_IS_DEFAULT(CICompilerCount)) { | |
| 128 FLAG_SET_DEFAULT(CICompilerCount, 3); | |
| 129 } | |
| 130 int count = CICompilerCount; | |
| 131 if (CICompilerCountPerCPU) { | |
| 132 count = MAX2(log2_intptr(os::active_processor_count()), 1) * 3 / 2; | |
| 133 } | |
| 134 set_c1_count(MAX2(count / 3, 1)); | |
| 135 set_c2_count(MAX2(count - count / 3, 1)); | |
| 136 } | |
| 137 | |
| 138 void SimpleThresholdPolicy::set_carry_if_necessary(InvocationCounter *counter) { | |
| 139 if (!counter->carry() && counter->count() > InvocationCounter::count_limit / 2) { | |
| 140 counter->set_carry_flag(); | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 // Set carry flags on the counters if necessary | |
| 145 void SimpleThresholdPolicy::handle_counter_overflow(methodOop method) { | |
| 146 set_carry_if_necessary(method->invocation_counter()); | |
| 147 set_carry_if_necessary(method->backedge_counter()); | |
| 148 methodDataOop mdo = method->method_data(); | |
| 149 if (mdo != NULL) { | |
| 150 set_carry_if_necessary(mdo->invocation_counter()); | |
| 151 set_carry_if_necessary(mdo->backedge_counter()); | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 // Called with the queue locked and with at least one element | |
| 156 CompileTask* SimpleThresholdPolicy::select_task(CompileQueue* compile_queue) { | |
| 157 return compile_queue->first(); | |
| 158 } | |
| 159 | |
| 2252 | 160 void SimpleThresholdPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) { |
| 161 for (ScopeDesc* sd = trap_scope;; sd = sd->sender()) { | |
| 162 if (PrintTieredEvents) { | |
| 163 methodHandle mh(sd->method()); | |
| 164 print_event(REPROFILE, mh, mh, InvocationEntryBci, CompLevel_none); | |
| 165 } | |
| 166 methodDataOop mdo = sd->method()->method_data(); | |
| 167 if (mdo != NULL) { | |
| 168 mdo->reset_start_counters(); | |
| 169 } | |
| 170 if (sd->is_top()) break; | |
| 171 } | |
| 172 } | |
| 173 | |
| 1783 | 174 nmethod* SimpleThresholdPolicy::event(methodHandle method, methodHandle inlinee, |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
175 int branch_bci, int bci, CompLevel comp_level, nmethod* nm, TRAPS) { |
| 1783 | 176 if (comp_level == CompLevel_none && |
| 177 JvmtiExport::can_post_interpreter_events()) { | |
| 178 assert(THREAD->is_Java_thread(), "Should be java thread"); | |
| 179 if (((JavaThread*)THREAD)->is_interp_only_mode()) { | |
| 180 return NULL; | |
| 181 } | |
| 182 } | |
| 183 nmethod *osr_nm = NULL; | |
| 184 | |
| 185 handle_counter_overflow(method()); | |
| 186 if (method() != inlinee()) { | |
| 187 handle_counter_overflow(inlinee()); | |
| 188 } | |
| 189 | |
| 190 if (PrintTieredEvents) { | |
| 191 print_event(bci == InvocationEntryBci ? CALL : LOOP, method, inlinee, bci, comp_level); | |
| 192 } | |
| 193 | |
| 194 if (bci == InvocationEntryBci) { | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
195 method_invocation_event(method, inlinee, comp_level, nm, THREAD); |
| 1783 | 196 } else { |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
197 method_back_branch_event(method, inlinee, bci, comp_level, nm, THREAD); |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
198 // method == inlinee if the event originated in the main method |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
199 int highest_level = inlinee->highest_osr_comp_level(); |
| 1783 | 200 if (highest_level > comp_level) { |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
201 osr_nm = inlinee->lookup_osr_nmethod_for(bci, highest_level, false); |
| 1783 | 202 } |
| 203 } | |
| 204 return osr_nm; | |
| 205 } | |
| 206 | |
| 207 // Check if the method can be compiled, change level if necessary | |
| 208 void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, TRAPS) { | |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
209 assert(level <= TieredStopAtLevel, "Invalid compilation level"); |
| 1783 | 210 if (level == CompLevel_none) { |
| 211 return; | |
| 212 } | |
|
1964
22ef3370343b
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
1783
diff
changeset
|
213 // Check if the method can be compiled. If it cannot be compiled with C1, continue profiling |
|
22ef3370343b
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
1783
diff
changeset
|
214 // in the interpreter and then compile with C2 (the transition function will request that, |
|
22ef3370343b
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
1783
diff
changeset
|
215 // see common() ). If the method cannot be compiled with C2 but still can with C1, compile it with |
|
22ef3370343b
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
1783
diff
changeset
|
216 // pure C1. |
| 1783 | 217 if (!can_be_compiled(mh, level)) { |
| 218 if (level == CompLevel_full_optimization && can_be_compiled(mh, CompLevel_simple)) { | |
| 219 compile(mh, bci, CompLevel_simple, THREAD); | |
| 220 } | |
| 221 return; | |
| 222 } | |
| 223 if (bci != InvocationEntryBci && mh->is_not_osr_compilable()) { | |
| 224 return; | |
| 225 } | |
| 226 if (!CompileBroker::compilation_is_in_queue(mh, bci)) { | |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
227 if (PrintTieredEvents) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
228 print_event(COMPILE, mh, mh, bci, level); |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
229 } |
| 1783 | 230 submit_compile(mh, bci, level, THREAD); |
| 231 } | |
| 232 } | |
| 233 | |
| 234 // Tell the broker to compile the method | |
| 235 void SimpleThresholdPolicy::submit_compile(methodHandle mh, int bci, CompLevel level, TRAPS) { | |
| 236 int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count(); | |
| 237 CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", THREAD); | |
| 238 } | |
| 239 | |
| 240 // Call and loop predicates determine whether a transition to a higher | |
| 241 // compilation level should be performed (pointers to predicate functions | |
| 242 // are passed to common() transition function). | |
| 243 bool SimpleThresholdPolicy::loop_predicate(int i, int b, CompLevel cur_level) { | |
| 244 switch(cur_level) { | |
| 245 case CompLevel_none: | |
| 246 case CompLevel_limited_profile: { | |
| 247 return loop_predicate_helper<CompLevel_none>(i, b, 1.0); | |
| 248 } | |
| 249 case CompLevel_full_profile: { | |
| 250 return loop_predicate_helper<CompLevel_full_profile>(i, b, 1.0); | |
| 251 } | |
| 252 default: | |
| 253 return true; | |
| 254 } | |
| 255 } | |
| 256 | |
| 257 bool SimpleThresholdPolicy::call_predicate(int i, int b, CompLevel cur_level) { | |
| 258 switch(cur_level) { | |
| 259 case CompLevel_none: | |
| 260 case CompLevel_limited_profile: { | |
| 261 return call_predicate_helper<CompLevel_none>(i, b, 1.0); | |
| 262 } | |
| 263 case CompLevel_full_profile: { | |
| 264 return call_predicate_helper<CompLevel_full_profile>(i, b, 1.0); | |
| 265 } | |
| 266 default: | |
| 267 return true; | |
| 268 } | |
| 269 } | |
| 270 | |
| 271 // Determine is a method is mature. | |
| 272 bool SimpleThresholdPolicy::is_mature(methodOop method) { | |
| 273 if (is_trivial(method)) return true; | |
| 274 methodDataOop mdo = method->method_data(); | |
| 275 if (mdo != NULL) { | |
| 276 int i = mdo->invocation_count(); | |
| 277 int b = mdo->backedge_count(); | |
| 278 double k = ProfileMaturityPercentage / 100.0; | |
| 279 return call_predicate_helper<CompLevel_full_profile>(i, b, k) || | |
| 280 loop_predicate_helper<CompLevel_full_profile>(i, b, k); | |
| 281 } | |
| 282 return false; | |
| 283 } | |
| 284 | |
| 285 // Common transition function. Given a predicate determines if a method should transition to another level. | |
| 286 CompLevel SimpleThresholdPolicy::common(Predicate p, methodOop method, CompLevel cur_level) { | |
| 287 CompLevel next_level = cur_level; | |
| 288 int i = method->invocation_count(); | |
| 289 int b = method->backedge_count(); | |
| 290 | |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
291 if (is_trivial(method)) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
292 next_level = CompLevel_simple; |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
293 } else { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
294 switch(cur_level) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
295 case CompLevel_none: |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
296 // If we were at full profile level, would we switch to full opt? |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
297 if (common(p, method, CompLevel_full_profile) == CompLevel_full_optimization) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
298 next_level = CompLevel_full_optimization; |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
299 } else if ((this->*p)(i, b, cur_level)) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
300 next_level = CompLevel_full_profile; |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
301 } |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
302 break; |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
303 case CompLevel_limited_profile: |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
304 case CompLevel_full_profile: |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
305 { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
306 methodDataOop mdo = method->method_data(); |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
307 if (mdo != NULL) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
308 if (mdo->would_profile()) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
309 int mdo_i = mdo->invocation_count_delta(); |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
310 int mdo_b = mdo->backedge_count_delta(); |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
311 if ((this->*p)(mdo_i, mdo_b, cur_level)) { |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
312 next_level = CompLevel_full_optimization; |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
313 } |
|
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
314 } else { |
| 2252 | 315 next_level = CompLevel_full_optimization; |
| 316 } | |
| 1783 | 317 } |
| 318 } | |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
319 break; |
| 1783 | 320 } |
| 321 } | |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
322 return MIN2(next_level, (CompLevel)TieredStopAtLevel); |
| 1783 | 323 } |
| 324 | |
| 325 // Determine if a method should be compiled with a normal entry point at a different level. | |
| 326 CompLevel SimpleThresholdPolicy::call_event(methodOop method, CompLevel cur_level) { | |
|
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
327 CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(), |
|
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
328 common(&SimpleThresholdPolicy::loop_predicate, method, cur_level)); |
| 1783 | 329 CompLevel next_level = common(&SimpleThresholdPolicy::call_predicate, method, cur_level); |
| 330 | |
| 331 // If OSR method level is greater than the regular method level, the levels should be | |
| 332 // equalized by raising the regular method level in order to avoid OSRs during each | |
| 333 // invocation of the method. | |
| 334 if (osr_level == CompLevel_full_optimization && cur_level == CompLevel_full_profile) { | |
| 335 methodDataOop mdo = method->method_data(); | |
| 336 guarantee(mdo != NULL, "MDO should not be NULL"); | |
| 337 if (mdo->invocation_count() >= 1) { | |
| 338 next_level = CompLevel_full_optimization; | |
| 339 } | |
| 340 } else { | |
| 341 next_level = MAX2(osr_level, next_level); | |
| 342 } | |
| 343 | |
| 344 return next_level; | |
| 345 } | |
| 346 | |
| 347 // Determine if we should do an OSR compilation of a given method. | |
| 348 CompLevel SimpleThresholdPolicy::loop_event(methodOop method, CompLevel cur_level) { | |
|
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
349 CompLevel next_level = common(&SimpleThresholdPolicy::loop_predicate, method, cur_level); |
| 1783 | 350 if (cur_level == CompLevel_none) { |
| 351 // If there is a live OSR method that means that we deopted to the interpreter | |
| 352 // for the transition. | |
|
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
353 CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level); |
| 1783 | 354 if (osr_level > CompLevel_none) { |
| 355 return osr_level; | |
| 356 } | |
| 357 } | |
|
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
358 return next_level; |
| 1783 | 359 } |
| 360 | |
| 361 | |
| 362 // Handle the invocation event. | |
| 363 void SimpleThresholdPolicy::method_invocation_event(methodHandle mh, methodHandle imh, | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
364 CompLevel level, nmethod* nm, TRAPS) { |
| 1783 | 365 if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh, InvocationEntryBci)) { |
| 366 CompLevel next_level = call_event(mh(), level); | |
| 367 if (next_level != level) { | |
| 368 compile(mh, InvocationEntryBci, next_level, THREAD); | |
| 369 } | |
| 370 } | |
| 371 } | |
| 372 | |
| 373 // Handle the back branch event. Notice that we can compile the method | |
| 374 // with a regular entry from here. | |
| 375 void SimpleThresholdPolicy::method_back_branch_event(methodHandle mh, methodHandle imh, | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
376 int bci, CompLevel level, nmethod* nm, TRAPS) { |
| 1783 | 377 // If the method is already compiling, quickly bail out. |
| 378 if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh, bci)) { | |
| 379 // Use loop event as an opportinity to also check there's been | |
| 380 // enough calls. | |
| 381 CompLevel cur_level = comp_level(mh()); | |
| 382 CompLevel next_level = call_event(mh(), cur_level); | |
| 383 CompLevel next_osr_level = loop_event(mh(), level); | |
| 384 | |
| 385 next_level = MAX2(next_level, | |
| 386 next_osr_level < CompLevel_full_optimization ? next_osr_level : cur_level); | |
| 387 bool is_compiling = false; | |
| 388 if (next_level != cur_level) { | |
| 389 compile(mh, InvocationEntryBci, next_level, THREAD); | |
| 390 is_compiling = true; | |
| 391 } | |
| 392 | |
| 393 // Do the OSR version | |
| 394 if (!is_compiling && next_osr_level != level) { | |
| 395 compile(mh, bci, next_osr_level, THREAD); | |
| 396 } | |
| 397 } | |
| 398 } |