Mercurial > hg > truffle
comparison src/share/vm/runtime/simpleThresholdPolicy.cpp @ 3837:43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
Summary: Added feedback disabling flag to common(), fixed handling of TieredStopAtLevel.
Reviewed-by: kvn, never
author | iveresov |
---|---|
date | Wed, 20 Jul 2011 18:04:17 -0700 |
parents | 2c359f27615c |
children | 973293defacd |
comparison
equal
deleted
inserted
replaced
3808:341a57af9b0a | 3837:43f9d800f276 |
---|---|
204 return osr_nm; | 204 return osr_nm; |
205 } | 205 } |
206 | 206 |
207 // Check if the method can be compiled, change level if necessary | 207 // Check if the method can be compiled, change level if necessary |
208 void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, TRAPS) { | 208 void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, TRAPS) { |
209 // Take the given ceiling into the account. | 209 assert(level <= TieredStopAtLevel, "Invalid compilation level"); |
210 // NOTE: You can set it to 1 to get a pure C1 version. | |
211 if ((CompLevel)TieredStopAtLevel < level) { | |
212 level = (CompLevel)TieredStopAtLevel; | |
213 } | |
214 if (level == CompLevel_none) { | 210 if (level == CompLevel_none) { |
215 return; | 211 return; |
216 } | 212 } |
217 // Check if the method can be compiled. If it cannot be compiled with C1, continue profiling | 213 // Check if the method can be compiled. If it cannot be compiled with C1, continue profiling |
218 // in the interpreter and then compile with C2 (the transition function will request that, | 214 // in the interpreter and then compile with C2 (the transition function will request that, |
225 return; | 221 return; |
226 } | 222 } |
227 if (bci != InvocationEntryBci && mh->is_not_osr_compilable()) { | 223 if (bci != InvocationEntryBci && mh->is_not_osr_compilable()) { |
228 return; | 224 return; |
229 } | 225 } |
230 if (PrintTieredEvents) { | |
231 print_event(COMPILE, mh, mh, bci, level); | |
232 } | |
233 if (!CompileBroker::compilation_is_in_queue(mh, bci)) { | 226 if (!CompileBroker::compilation_is_in_queue(mh, bci)) { |
227 if (PrintTieredEvents) { | |
228 print_event(COMPILE, mh, mh, bci, level); | |
229 } | |
234 submit_compile(mh, bci, level, THREAD); | 230 submit_compile(mh, bci, level, THREAD); |
235 } | 231 } |
236 } | 232 } |
237 | 233 |
238 // Tell the broker to compile the method | 234 // Tell the broker to compile the method |
286 return false; | 282 return false; |
287 } | 283 } |
288 | 284 |
289 // Common transition function. Given a predicate determines if a method should transition to another level. | 285 // Common transition function. Given a predicate determines if a method should transition to another level. |
290 CompLevel SimpleThresholdPolicy::common(Predicate p, methodOop method, CompLevel cur_level) { | 286 CompLevel SimpleThresholdPolicy::common(Predicate p, methodOop method, CompLevel cur_level) { |
291 if (is_trivial(method)) return CompLevel_simple; | |
292 | |
293 CompLevel next_level = cur_level; | 287 CompLevel next_level = cur_level; |
294 int i = method->invocation_count(); | 288 int i = method->invocation_count(); |
295 int b = method->backedge_count(); | 289 int b = method->backedge_count(); |
296 | 290 |
297 switch(cur_level) { | 291 if (is_trivial(method)) { |
298 case CompLevel_none: | 292 next_level = CompLevel_simple; |
299 // If we were at full profile level, would we switch to full opt? | 293 } else { |
300 if (common(p, method, CompLevel_full_profile) == CompLevel_full_optimization) { | 294 switch(cur_level) { |
301 next_level = CompLevel_full_optimization; | 295 case CompLevel_none: |
302 } else if ((this->*p)(i, b, cur_level)) { | 296 // If we were at full profile level, would we switch to full opt? |
303 next_level = CompLevel_full_profile; | 297 if (common(p, method, CompLevel_full_profile) == CompLevel_full_optimization) { |
304 } | 298 next_level = CompLevel_full_optimization; |
305 break; | 299 } else if ((this->*p)(i, b, cur_level)) { |
306 case CompLevel_limited_profile: | 300 next_level = CompLevel_full_profile; |
307 case CompLevel_full_profile: | 301 } |
308 { | 302 break; |
309 methodDataOop mdo = method->method_data(); | 303 case CompLevel_limited_profile: |
310 if (mdo != NULL) { | 304 case CompLevel_full_profile: |
311 if (mdo->would_profile()) { | 305 { |
312 int mdo_i = mdo->invocation_count_delta(); | 306 methodDataOop mdo = method->method_data(); |
313 int mdo_b = mdo->backedge_count_delta(); | 307 if (mdo != NULL) { |
314 if ((this->*p)(mdo_i, mdo_b, cur_level)) { | 308 if (mdo->would_profile()) { |
309 int mdo_i = mdo->invocation_count_delta(); | |
310 int mdo_b = mdo->backedge_count_delta(); | |
311 if ((this->*p)(mdo_i, mdo_b, cur_level)) { | |
312 next_level = CompLevel_full_optimization; | |
313 } | |
314 } else { | |
315 next_level = CompLevel_full_optimization; | 315 next_level = CompLevel_full_optimization; |
316 } | 316 } |
317 } else { | |
318 next_level = CompLevel_full_optimization; | |
319 } | 317 } |
320 } | 318 } |
321 } | 319 break; |
322 break; | 320 } |
323 } | 321 } |
324 return next_level; | 322 return MIN2(next_level, (CompLevel)TieredStopAtLevel); |
325 } | 323 } |
326 | 324 |
327 // Determine if a method should be compiled with a normal entry point at a different level. | 325 // Determine if a method should be compiled with a normal entry point at a different level. |
328 CompLevel SimpleThresholdPolicy::call_event(methodOop method, CompLevel cur_level) { | 326 CompLevel SimpleThresholdPolicy::call_event(methodOop method, CompLevel cur_level) { |
329 CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(), | 327 CompLevel osr_level = MIN2((CompLevel) method->highest_osr_comp_level(), |