Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/simpleThresholdPolicy.hpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | 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 #ifndef SHARE_VM_RUNTIME_SIMPLETHRESHOLDPOLICY_HPP |
| 26 #define SHARE_VM_RUNTIME_SIMPLETHRESHOLDPOLICY_HPP | |
| 27 | |
| 28 #include "code/nmethod.hpp" | |
| 29 #include "oops/methodDataOop.hpp" | |
| 30 #include "runtime/compilationPolicy.hpp" | |
| 31 #include "utilities/globalDefinitions.hpp" | |
| 32 | |
| 1783 | 33 class CompileTask; |
| 34 class CompileQueue; | |
| 35 | |
| 36 class SimpleThresholdPolicy : public CompilationPolicy { | |
| 37 int _c1_count, _c2_count; | |
| 38 | |
| 39 // Check if the counter is big enough and set carry (effectively infinity). | |
| 40 inline void set_carry_if_necessary(InvocationCounter *counter); | |
| 41 // Set carry flags in the counters (in methodOop and MDO). | |
| 42 inline void handle_counter_overflow(methodOop method); | |
| 43 // Call and loop predicates determine whether a transition to a higher compilation | |
| 44 // level should be performed (pointers to predicate functions are passed to common_TF(). | |
| 45 // Predicates also take compiler load into account. | |
| 46 typedef bool (SimpleThresholdPolicy::*Predicate)(int i, int b, CompLevel cur_level); | |
| 47 bool call_predicate(int i, int b, CompLevel cur_level); | |
| 48 bool loop_predicate(int i, int b, CompLevel cur_level); | |
| 49 // Common transition function. Given a predicate determines if a method should transition to another level. | |
| 50 CompLevel common(Predicate p, methodOop method, CompLevel cur_level); | |
| 51 // Transition functions. | |
| 52 // call_event determines if a method should be compiled at a different | |
| 53 // level with a regular invocation entry. | |
| 54 CompLevel call_event(methodOop method, CompLevel cur_level); | |
| 55 // loop_event checks if a method should be OSR compiled at a different | |
| 56 // level. | |
| 57 CompLevel loop_event(methodOop method, CompLevel cur_level); | |
| 58 | |
| 59 protected: | |
| 60 int c1_count() const { return _c1_count; } | |
| 61 int c2_count() const { return _c2_count; } | |
| 62 void set_c1_count(int x) { _c1_count = x; } | |
| 63 void set_c2_count(int x) { _c2_count = x; } | |
| 64 | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
65 enum EventType { CALL, LOOP, COMPILE, REMOVE_FROM_QUEUE, UPDATE_IN_QUEUE, REPROFILE, MAKE_NOT_ENTRANT }; |
| 1783 | 66 void print_event(EventType type, methodHandle mh, methodHandle imh, int bci, CompLevel level); |
| 67 // Print policy-specific information if necessary | |
| 68 virtual void print_specific(EventType type, methodHandle mh, methodHandle imh, int bci, CompLevel level) { } | |
| 69 // Check if the method can be compiled, change level if necessary | |
| 70 void compile(methodHandle mh, int bci, CompLevel level, TRAPS); | |
| 71 // Submit a given method for compilation | |
| 72 virtual void submit_compile(methodHandle mh, int bci, CompLevel level, TRAPS); | |
| 73 // Simple methods are as good being compiled with C1 as C2. | |
| 74 // This function tells if it's such a function. | |
| 75 inline bool is_trivial(methodOop method); | |
| 76 | |
| 77 // Predicate helpers are used by .*_predicate() methods as well as others. | |
| 78 // They check the given counter values, multiplied by the scale against the thresholds. | |
| 79 template<CompLevel level> static inline bool call_predicate_helper(int i, int b, double scale); | |
| 80 template<CompLevel level> static inline bool loop_predicate_helper(int i, int b, double scale); | |
| 81 | |
| 82 // Get a compilation level for a given method. | |
| 83 static CompLevel comp_level(methodOop method) { | |
| 84 nmethod *nm = method->code(); | |
| 85 if (nm != NULL && nm->is_in_use()) { | |
| 86 return (CompLevel)nm->comp_level(); | |
| 87 } | |
| 88 return CompLevel_none; | |
| 89 } | |
| 90 virtual void method_invocation_event(methodHandle method, methodHandle inlinee, | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
91 CompLevel level, nmethod* nm, TRAPS); |
| 1783 | 92 virtual void method_back_branch_event(methodHandle method, methodHandle inlinee, |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
93 int bci, CompLevel level, nmethod* nm, TRAPS); |
| 1783 | 94 public: |
| 95 SimpleThresholdPolicy() : _c1_count(0), _c2_count(0) { } | |
| 96 virtual int compiler_count(CompLevel comp_level) { | |
| 97 if (is_c1_compile(comp_level)) return c1_count(); | |
| 98 if (is_c2_compile(comp_level)) return c2_count(); | |
| 99 return 0; | |
| 100 } | |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3791
diff
changeset
|
101 virtual CompLevel initial_compile_level() { return MIN2((CompLevel)TieredStopAtLevel, CompLevel_initial_compile); } |
| 1783 | 102 virtual void do_safepoint_work() { } |
| 103 virtual void delay_compilation(methodOop method) { } | |
| 104 virtual void disable_compilation(methodOop method) { } | |
| 2252 | 105 virtual void reprofile(ScopeDesc* trap_scope, bool is_osr); |
| 1783 | 106 virtual nmethod* event(methodHandle method, methodHandle inlinee, |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
107 int branch_bci, int bci, CompLevel comp_level, nmethod* nm, TRAPS); |
| 1783 | 108 // Select task is called by CompileBroker. We should return a task or NULL. |
| 109 virtual CompileTask* select_task(CompileQueue* compile_queue); | |
| 110 // Tell the runtime if we think a given method is adequately profiled. | |
| 111 virtual bool is_mature(methodOop method); | |
| 112 // Initialize: set compiler thread count | |
| 113 virtual void initialize(); | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
114 virtual bool should_not_inline(ciEnv* env, ciMethod* callee) { |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
115 return (env->comp_level() == CompLevel_limited_profile || |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
116 env->comp_level() == CompLevel_full_profile) && |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
117 callee->has_loops(); |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3358
diff
changeset
|
118 } |
| 1783 | 119 }; |
| 1972 | 120 |
| 121 #endif // SHARE_VM_RUNTIME_SIMPLETHRESHOLDPOLICY_HPP |