Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/simpleThresholdPolicy.cpp @ 10292:acac2b03a07f
8014765: VM exits if MaxTenuringThreshold is set below the default InitialTenuringThreshold, and InitialTenuringThreshold is not set
Summary: The VM exits when the condition in the subject line applies. The fix sets InitialTenuringThreshold to MaxTenuringThreshold if it is larger than MaxTenuringThreshold and InitialTenuringThreshold has not been set (is default).
Reviewed-by: jwilhelm, jmasa, brutisso, johnc
author | tschatzl |
---|---|
date | Thu, 16 May 2013 23:51:51 +0200 |
parents | 487d442ef257 |
children | 63a4eb8bcd23 7150b16fda52 |
rev | line source |
---|---|
1783 | 1 /* |
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
6800
diff
changeset
|
2 * Copyright (c) 2010, 2013, 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 |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
33 |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
34 void SimpleThresholdPolicy::print_counters(const char* prefix, methodHandle mh) { |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
35 int invocation_count = mh->invocation_count(); |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
36 int backedge_count = mh->backedge_count(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
37 MethodData* mdh = mh->method_data(); |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
38 int mdo_invocations = 0, mdo_backedges = 0; |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
39 int mdo_invocations_start = 0, mdo_backedges_start = 0; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
40 if (mdh != NULL) { |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
41 mdo_invocations = mdh->invocation_count(); |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
42 mdo_backedges = mdh->backedge_count(); |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
43 mdo_invocations_start = mdh->invocation_count_start(); |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
44 mdo_backedges_start = mdh->backedge_count_start(); |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
45 } |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
46 tty->print(" %stotal=%d,%d %smdo=%d(%d),%d(%d)", prefix, |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
47 invocation_count, backedge_count, prefix, |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
48 mdo_invocations, mdo_invocations_start, |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
49 mdo_backedges, mdo_backedges_start); |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
50 tty->print(" %smax levels=%d,%d", prefix, |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
51 mh->highest_comp_level(), mh->highest_osr_comp_level()); |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
52 } |
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
53 |
1783 | 54 // Print an event. |
55 void SimpleThresholdPolicy::print_event(EventType type, methodHandle mh, methodHandle imh, | |
56 int bci, CompLevel level) { | |
57 bool inlinee_event = mh() != imh(); | |
58 | |
59 ttyLocker tty_lock; | |
60 tty->print("%lf: [", os::elapsedTime()); | |
61 | |
62 switch(type) { | |
63 case CALL: | |
64 tty->print("call"); | |
65 break; | |
66 case LOOP: | |
67 tty->print("loop"); | |
68 break; | |
69 case COMPILE: | |
70 tty->print("compile"); | |
2252 | 71 break; |
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
72 case REMOVE_FROM_QUEUE: |
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
73 tty->print("remove-from-queue"); |
2252 | 74 break; |
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
75 case UPDATE_IN_QUEUE: |
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
76 tty->print("update-in-queue"); |
2252 | 77 break; |
78 case REPROFILE: | |
79 tty->print("reprofile"); | |
80 break; | |
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
81 case MAKE_NOT_ENTRANT: |
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
82 tty->print("make-not-entrant"); |
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
83 break; |
2252 | 84 default: |
85 tty->print("unknown"); | |
1783 | 86 } |
87 | |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
88 tty->print(" level=%d ", level); |
1783 | 89 |
90 ResourceMark rm; | |
91 char *method_name = mh->name_and_sig_as_C_string(); | |
92 tty->print("[%s", method_name); | |
93 if (inlinee_event) { | |
94 char *inlinee_name = imh->name_and_sig_as_C_string(); | |
95 tty->print(" [%s]] ", inlinee_name); | |
96 } | |
97 else tty->print("] "); | |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
98 tty->print("@%d queues=%d,%d", bci, CompileBroker::queue_size(CompLevel_full_profile), |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
99 CompileBroker::queue_size(CompLevel_full_optimization)); |
1783 | 100 |
101 print_specific(type, mh, imh, bci, level); | |
102 | |
103 if (type != COMPILE) { | |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
104 print_counters("", mh); |
1783 | 105 if (inlinee_event) { |
4116
973293defacd
7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents:
3837
diff
changeset
|
106 print_counters("inlinee ", imh); |
1783 | 107 } |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
108 tty->print(" compilable="); |
1783 | 109 bool need_comma = false; |
110 if (!mh->is_not_compilable(CompLevel_full_profile)) { | |
111 tty->print("c1"); | |
112 need_comma = true; | |
113 } | |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
114 if (!mh->is_not_osr_compilable(CompLevel_full_profile)) { |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
115 if (need_comma) tty->print(","); |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
116 tty->print("c1-osr"); |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
117 need_comma = true; |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
118 } |
1783 | 119 if (!mh->is_not_compilable(CompLevel_full_optimization)) { |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
120 if (need_comma) tty->print(","); |
1783 | 121 tty->print("c2"); |
122 need_comma = true; | |
123 } | |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
124 if (!mh->is_not_osr_compilable(CompLevel_full_optimization)) { |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
125 if (need_comma) tty->print(","); |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
126 tty->print("c2-osr"); |
1783 | 127 } |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
128 tty->print(" status="); |
1783 | 129 if (mh->queued_for_compilation()) { |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
130 tty->print("in-queue"); |
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
131 } else tty->print("idle"); |
1783 | 132 } |
133 tty->print_cr("]"); | |
134 } | |
135 | |
136 void SimpleThresholdPolicy::initialize() { | |
137 if (FLAG_IS_DEFAULT(CICompilerCount)) { | |
138 FLAG_SET_DEFAULT(CICompilerCount, 3); | |
139 } | |
140 int count = CICompilerCount; | |
141 if (CICompilerCountPerCPU) { | |
142 count = MAX2(log2_intptr(os::active_processor_count()), 1) * 3 / 2; | |
143 } | |
144 set_c1_count(MAX2(count / 3, 1)); | |
145 set_c2_count(MAX2(count - count / 3, 1)); | |
146 } | |
147 | |
148 void SimpleThresholdPolicy::set_carry_if_necessary(InvocationCounter *counter) { | |
149 if (!counter->carry() && counter->count() > InvocationCounter::count_limit / 2) { | |
150 counter->set_carry_flag(); | |
151 } | |
152 } | |
153 | |
154 // Set carry flags on the counters if necessary | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
155 void SimpleThresholdPolicy::handle_counter_overflow(Method* method) { |
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
6800
diff
changeset
|
156 MethodCounters *mcs = method->method_counters(); |
10204
487d442ef257
8013036: vm/runtime/simpleThresholdPolicy.cpp: assert(mcs != NULL).
jiangli
parents:
10105
diff
changeset
|
157 if (mcs != NULL) { |
487d442ef257
8013036: vm/runtime/simpleThresholdPolicy.cpp: assert(mcs != NULL).
jiangli
parents:
10105
diff
changeset
|
158 set_carry_if_necessary(mcs->invocation_counter()); |
487d442ef257
8013036: vm/runtime/simpleThresholdPolicy.cpp: assert(mcs != NULL).
jiangli
parents:
10105
diff
changeset
|
159 set_carry_if_necessary(mcs->backedge_counter()); |
487d442ef257
8013036: vm/runtime/simpleThresholdPolicy.cpp: assert(mcs != NULL).
jiangli
parents:
10105
diff
changeset
|
160 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
161 MethodData* mdo = method->method_data(); |
1783 | 162 if (mdo != NULL) { |
163 set_carry_if_necessary(mdo->invocation_counter()); | |
164 set_carry_if_necessary(mdo->backedge_counter()); | |
165 } | |
166 } | |
167 | |
168 // Called with the queue locked and with at least one element | |
169 CompileTask* SimpleThresholdPolicy::select_task(CompileQueue* compile_queue) { | |
170 return compile_queue->first(); | |
171 } | |
172 | |
2252 | 173 void SimpleThresholdPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) { |
174 for (ScopeDesc* sd = trap_scope;; sd = sd->sender()) { | |
175 if (PrintTieredEvents) { | |
176 methodHandle mh(sd->method()); | |
177 print_event(REPROFILE, mh, mh, InvocationEntryBci, CompLevel_none); | |
178 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
179 MethodData* mdo = sd->method()->method_data(); |
2252 | 180 if (mdo != NULL) { |
181 mdo->reset_start_counters(); | |
182 } | |
183 if (sd->is_top()) break; | |
184 } | |
185 } | |
186 | |
1783 | 187 nmethod* SimpleThresholdPolicy::event(methodHandle method, methodHandle inlinee, |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
188 int branch_bci, int bci, CompLevel comp_level, nmethod* nm, JavaThread* thread) { |
1783 | 189 if (comp_level == CompLevel_none && |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
190 JvmtiExport::can_post_interpreter_events() && |
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
191 thread->is_interp_only_mode()) { |
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
192 return NULL; |
1783 | 193 } |
194 nmethod *osr_nm = NULL; | |
195 | |
196 handle_counter_overflow(method()); | |
197 if (method() != inlinee()) { | |
198 handle_counter_overflow(inlinee()); | |
199 } | |
200 | |
201 if (PrintTieredEvents) { | |
202 print_event(bci == InvocationEntryBci ? CALL : LOOP, method, inlinee, bci, comp_level); | |
203 } | |
204 | |
205 if (bci == InvocationEntryBci) { | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
206 method_invocation_event(method, inlinee, comp_level, nm, thread); |
1783 | 207 } else { |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
208 method_back_branch_event(method, inlinee, bci, comp_level, nm, thread); |
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
209 // 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
|
210 int highest_level = inlinee->highest_osr_comp_level(); |
1783 | 211 if (highest_level > comp_level) { |
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3790
diff
changeset
|
212 osr_nm = inlinee->lookup_osr_nmethod_for(bci, highest_level, false); |
1783 | 213 } |
214 } | |
215 return osr_nm; | |
216 } | |
217 | |
218 // Check if the method can be compiled, change level if necessary | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
219 void SimpleThresholdPolicy::compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread) { |
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
220 assert(level <= TieredStopAtLevel, "Invalid compilation level"); |
1783 | 221 if (level == CompLevel_none) { |
222 return; | |
223 } | |
1964
22ef3370343b
7000349: Tiered reacts incorrectly to C1 compilation failures
iveresov
parents:
1783
diff
changeset
|
224 // 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
|
225 // 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
|
226 // 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
|
227 // pure C1. |
1783 | 228 if (!can_be_compiled(mh, level)) { |
229 if (level == CompLevel_full_optimization && can_be_compiled(mh, CompLevel_simple)) { | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
230 compile(mh, bci, CompLevel_simple, thread); |
1783 | 231 } |
232 return; | |
233 } | |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6725
diff
changeset
|
234 if (bci != InvocationEntryBci && mh->is_not_osr_compilable(level)) { |
1783 | 235 return; |
236 } | |
237 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
|
238 if (PrintTieredEvents) { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
239 print_event(COMPILE, mh, mh, bci, level); |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
240 } |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
241 submit_compile(mh, bci, level, thread); |
1783 | 242 } |
243 } | |
244 | |
245 // Tell the broker to compile the method | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
246 void SimpleThresholdPolicy::submit_compile(methodHandle mh, int bci, CompLevel level, JavaThread* thread) { |
1783 | 247 int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count(); |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
248 CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", thread); |
1783 | 249 } |
250 | |
251 // Call and loop predicates determine whether a transition to a higher | |
252 // compilation level should be performed (pointers to predicate functions | |
253 // are passed to common() transition function). | |
254 bool SimpleThresholdPolicy::loop_predicate(int i, int b, CompLevel cur_level) { | |
255 switch(cur_level) { | |
256 case CompLevel_none: | |
257 case CompLevel_limited_profile: { | |
258 return loop_predicate_helper<CompLevel_none>(i, b, 1.0); | |
259 } | |
260 case CompLevel_full_profile: { | |
261 return loop_predicate_helper<CompLevel_full_profile>(i, b, 1.0); | |
262 } | |
263 default: | |
264 return true; | |
265 } | |
266 } | |
267 | |
268 bool SimpleThresholdPolicy::call_predicate(int i, int b, CompLevel cur_level) { | |
269 switch(cur_level) { | |
270 case CompLevel_none: | |
271 case CompLevel_limited_profile: { | |
272 return call_predicate_helper<CompLevel_none>(i, b, 1.0); | |
273 } | |
274 case CompLevel_full_profile: { | |
275 return call_predicate_helper<CompLevel_full_profile>(i, b, 1.0); | |
276 } | |
277 default: | |
278 return true; | |
279 } | |
280 } | |
281 | |
282 // Determine is a method is mature. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
283 bool SimpleThresholdPolicy::is_mature(Method* method) { |
1783 | 284 if (is_trivial(method)) return true; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
285 MethodData* mdo = method->method_data(); |
1783 | 286 if (mdo != NULL) { |
287 int i = mdo->invocation_count(); | |
288 int b = mdo->backedge_count(); | |
289 double k = ProfileMaturityPercentage / 100.0; | |
290 return call_predicate_helper<CompLevel_full_profile>(i, b, k) || | |
291 loop_predicate_helper<CompLevel_full_profile>(i, b, k); | |
292 } | |
293 return false; | |
294 } | |
295 | |
296 // Common transition function. Given a predicate determines if a method should transition to another level. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
297 CompLevel SimpleThresholdPolicy::common(Predicate p, Method* method, CompLevel cur_level) { |
1783 | 298 CompLevel next_level = cur_level; |
299 int i = method->invocation_count(); | |
300 int b = method->backedge_count(); | |
301 | |
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
302 if (is_trivial(method)) { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
303 next_level = CompLevel_simple; |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
304 } else { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
305 switch(cur_level) { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
306 case CompLevel_none: |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
307 // 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
|
308 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
|
309 next_level = CompLevel_full_optimization; |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
310 } else if ((this->*p)(i, b, cur_level)) { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
311 next_level = CompLevel_full_profile; |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
312 } |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
313 break; |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
314 case CompLevel_limited_profile: |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
315 case CompLevel_full_profile: |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
316 { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
317 MethodData* mdo = method->method_data(); |
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
318 if (mdo != NULL) { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
319 if (mdo->would_profile()) { |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
320 int mdo_i = mdo->invocation_count_delta(); |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
321 int mdo_b = mdo->backedge_count_delta(); |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
322 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
|
323 next_level = CompLevel_full_optimization; |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
324 } |
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
325 } else { |
2252 | 326 next_level = CompLevel_full_optimization; |
327 } | |
1783 | 328 } |
329 } | |
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
330 break; |
1783 | 331 } |
332 } | |
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
333 return MIN2(next_level, (CompLevel)TieredStopAtLevel); |
1783 | 334 } |
335 | |
336 // Determine if a method should be compiled with a normal entry point at a different level. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
337 CompLevel SimpleThresholdPolicy::call_event(Method* method, CompLevel cur_level) { |
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
338 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
|
339 common(&SimpleThresholdPolicy::loop_predicate, method, cur_level)); |
1783 | 340 CompLevel next_level = common(&SimpleThresholdPolicy::call_predicate, method, cur_level); |
341 | |
342 // If OSR method level is greater than the regular method level, the levels should be | |
343 // equalized by raising the regular method level in order to avoid OSRs during each | |
344 // invocation of the method. | |
345 if (osr_level == CompLevel_full_optimization && cur_level == CompLevel_full_profile) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
346 MethodData* mdo = method->method_data(); |
1783 | 347 guarantee(mdo != NULL, "MDO should not be NULL"); |
348 if (mdo->invocation_count() >= 1) { | |
349 next_level = CompLevel_full_optimization; | |
350 } | |
351 } else { | |
352 next_level = MAX2(osr_level, next_level); | |
353 } | |
354 | |
355 return next_level; | |
356 } | |
357 | |
358 // Determine if we should do an OSR compilation of a given method. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4825
diff
changeset
|
359 CompLevel SimpleThresholdPolicy::loop_event(Method* method, CompLevel cur_level) { |
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
360 CompLevel next_level = common(&SimpleThresholdPolicy::loop_predicate, method, cur_level); |
1783 | 361 if (cur_level == CompLevel_none) { |
362 // If there is a live OSR method that means that we deopted to the interpreter | |
363 // for the transition. | |
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
364 CompLevel osr_level = MIN2((CompLevel)method->highest_osr_comp_level(), next_level); |
1783 | 365 if (osr_level > CompLevel_none) { |
366 return osr_level; | |
367 } | |
368 } | |
3790
6f6e91603a45
7058689: Tiered: Reprofiling doesn't happen in presence of level 4 OSR methods
iveresov
parents:
3358
diff
changeset
|
369 return next_level; |
1783 | 370 } |
371 | |
372 | |
373 // Handle the invocation event. | |
374 void SimpleThresholdPolicy::method_invocation_event(methodHandle mh, methodHandle imh, | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
375 CompLevel level, nmethod* nm, JavaThread* thread) { |
1783 | 376 if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh, InvocationEntryBci)) { |
377 CompLevel next_level = call_event(mh(), level); | |
378 if (next_level != level) { | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
379 compile(mh, InvocationEntryBci, next_level, thread); |
1783 | 380 } |
381 } | |
382 } | |
383 | |
384 // Handle the back branch event. Notice that we can compile the method | |
385 // with a regular entry from here. | |
386 void SimpleThresholdPolicy::method_back_branch_event(methodHandle mh, methodHandle imh, | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
387 int bci, CompLevel level, nmethod* nm, JavaThread* thread) { |
1783 | 388 // If the method is already compiling, quickly bail out. |
389 if (is_compilation_enabled() && !CompileBroker::compilation_is_in_queue(mh, bci)) { | |
390 // Use loop event as an opportinity to also check there's been | |
391 // enough calls. | |
392 CompLevel cur_level = comp_level(mh()); | |
393 CompLevel next_level = call_event(mh(), cur_level); | |
394 CompLevel next_osr_level = loop_event(mh(), level); | |
395 | |
396 next_level = MAX2(next_level, | |
397 next_osr_level < CompLevel_full_optimization ? next_osr_level : cur_level); | |
398 bool is_compiling = false; | |
399 if (next_level != cur_level) { | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
400 compile(mh, InvocationEntryBci, next_level, thread); |
1783 | 401 is_compiling = true; |
402 } | |
403 | |
404 // Do the OSR version | |
405 if (!is_compiling && next_osr_level != level) { | |
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4116
diff
changeset
|
406 compile(mh, bci, next_osr_level, thread); |
1783 | 407 } |
408 } | |
409 } |