Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/deoptimization.hpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
| author | ysr |
|---|---|
| date | Wed, 16 Mar 2011 10:37:08 -0700 |
| parents | f95d63e2154a |
| children | 4f148718983e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, 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:
1206
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1206
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:
1206
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_DEOPTIMIZATION_HPP |
| 26 #define SHARE_VM_RUNTIME_DEOPTIMIZATION_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "runtime/frame.inline.hpp" | |
| 30 | |
| 0 | 31 class ProfileData; |
| 32 class vframeArray; | |
| 33 class MonitorValue; | |
| 34 class ObjectValue; | |
| 35 | |
| 36 class Deoptimization : AllStatic { | |
| 37 public: | |
| 38 // What condition caused the deoptimization? | |
| 39 enum DeoptReason { | |
| 40 Reason_many = -1, // indicates presence of several reasons | |
| 41 Reason_none = 0, // indicates absence of a relevant deopt. | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1172
diff
changeset
|
42 // Next 7 reasons are recorded per bytecode in DataLayout::trap_bits |
| 0 | 43 Reason_null_check, // saw unexpected null or zero divisor (@bci) |
| 44 Reason_null_assert, // saw unexpected non-null or non-zero (@bci) | |
| 45 Reason_range_check, // saw unexpected array index (@bci) | |
| 46 Reason_class_check, // saw unexpected object class (@bci) | |
| 47 Reason_array_check, // saw unexpected array class (aastore @bci) | |
| 48 Reason_intrinsic, // saw unexpected operand to intrinsic (@bci) | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1172
diff
changeset
|
49 Reason_bimorphic, // saw unexpected object class in bimorphic inlining (@bci) |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1172
diff
changeset
|
50 |
| 0 | 51 Reason_unloaded, // unloaded class or constant pool entry |
| 52 Reason_uninitialized, // bad class state (uninitialized) | |
| 53 Reason_unreached, // code is not reached, compiler | |
| 54 Reason_unhandled, // arbitrary compiler limitation | |
| 55 Reason_constraint, // arbitrary runtime constraint violated | |
| 56 Reason_div0_check, // a null_check due to division by zero | |
| 57 Reason_age, // nmethod too old; tier threshold reached | |
| 1172 | 58 Reason_predicate, // compiler generated predicate failed |
| 0 | 59 Reason_LIMIT, |
| 60 // Note: Keep this enum in sync. with _trap_reason_name. | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1172
diff
changeset
|
61 Reason_RECORDED_LIMIT = Reason_bimorphic // some are not recorded per bc |
| 0 | 62 // Note: Reason_RECORDED_LIMIT should be < 8 to fit into 3 bits of |
| 63 // DataLayout::trap_bits. This dependency is enforced indirectly | |
| 64 // via asserts, to avoid excessive direct header-to-header dependencies. | |
| 65 // See Deoptimization::trap_state_reason and class DataLayout. | |
| 66 }; | |
| 67 | |
| 68 // What action must be taken by the runtime? | |
| 69 enum DeoptAction { | |
| 70 Action_none, // just interpret, do not invalidate nmethod | |
| 71 Action_maybe_recompile, // recompile the nmethod; need not invalidate | |
| 72 Action_reinterpret, // invalidate the nmethod, reset IC, maybe recompile | |
| 73 Action_make_not_entrant, // invalidate the nmethod, recompile (probably) | |
| 74 Action_make_not_compilable, // invalidate the nmethod and do not compile | |
| 75 Action_LIMIT | |
| 76 // Note: Keep this enum in sync. with _trap_action_name. | |
| 77 }; | |
| 78 | |
| 79 enum { | |
| 80 _action_bits = 3, | |
| 81 _reason_bits = 4, | |
| 82 _action_shift = 0, | |
| 83 _reason_shift = _action_shift+_action_bits, | |
| 84 BC_CASE_LIMIT = PRODUCT_ONLY(1) NOT_PRODUCT(4) // for _deoptimization_hist | |
| 85 }; | |
| 86 | |
| 87 enum UnpackType { | |
| 88 Unpack_deopt = 0, // normal deoptimization, use pc computed in unpack_vframe_on_stack | |
| 89 Unpack_exception = 1, // exception is pending | |
| 90 Unpack_uncommon_trap = 2, // redo last byte code (C2 only) | |
| 91 Unpack_reexecute = 3 // reexecute bytecode (C1 only) | |
| 92 }; | |
| 93 | |
| 94 // Checks all compiled methods. Invalid methods are deleted and | |
| 95 // corresponding activations are deoptimized. | |
| 96 static int deoptimize_dependents(); | |
| 97 | |
| 98 // Deoptimizes a frame lazily. nmethod gets patched deopt happens on return to the frame | |
| 99 static void deoptimize(JavaThread* thread, frame fr, RegisterMap *reg_map); | |
| 100 | |
| 101 private: | |
| 102 // Does the actual work for deoptimizing a single frame | |
| 103 static void deoptimize_single_frame(JavaThread* thread, frame fr); | |
| 104 | |
| 105 // Helper function to revoke biases of all monitors in frame if UseBiasedLocking | |
| 106 // is enabled | |
| 107 static void revoke_biases_of_monitors(JavaThread* thread, frame fr, RegisterMap* map); | |
| 108 // Helper function to revoke biases of all monitors in frames | |
| 109 // executing in a particular CodeBlob if UseBiasedLocking is enabled | |
| 110 static void revoke_biases_of_monitors(CodeBlob* cb); | |
| 111 | |
| 112 #ifdef COMPILER2 | |
| 113 // Support for restoring non-escaping objects | |
| 114 static bool realloc_objects(JavaThread* thread, frame* fr, GrowableArray<ScopeValue*>* objects, TRAPS); | |
| 115 static void reassign_type_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, typeArrayOop obj, BasicType type); | |
| 116 static void reassign_object_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, objArrayOop obj); | |
| 117 static void reassign_fields(frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects); | |
|
83
d3cd40645d0d
6681646: Relocking of a scalar replaced object during deoptimization is broken
kvn
parents:
0
diff
changeset
|
118 static void relock_objects(GrowableArray<MonitorInfo*>* monitors, JavaThread* thread); |
| 0 | 119 NOT_PRODUCT(static void print_objects(GrowableArray<ScopeValue*>* objects);) |
| 120 #endif // COMPILER2 | |
| 121 | |
| 122 public: | |
| 123 static vframeArray* create_vframeArray(JavaThread* thread, frame fr, RegisterMap *reg_map, GrowableArray<compiledVFrame*>* chunk); | |
| 124 | |
| 125 // Interface used for unpacking deoptimized frames | |
| 126 | |
| 127 // UnrollBlock is returned by fetch_unroll_info() to the deoptimization handler (blob). | |
| 128 // This is only a CheapObj to ease debugging after a deopt failure | |
| 129 class UnrollBlock : public CHeapObj { | |
| 130 private: | |
| 131 int _size_of_deoptimized_frame; // Size, in bytes, of current deoptimized frame | |
| 132 int _caller_adjustment; // Adjustment, in bytes, to caller's SP by initial interpreted frame | |
| 133 int _number_of_frames; // Number frames to unroll | |
| 134 int _total_frame_sizes; // Total of number*sizes frames | |
| 135 intptr_t* _frame_sizes; // Array of frame sizes, in bytes, for unrolling the stack | |
| 136 address* _frame_pcs; // Array of frame pc's, in bytes, for unrolling the stack | |
| 137 intptr_t* _register_block; // Block for storing callee-saved registers. | |
| 138 BasicType _return_type; // Tells if we have to restore double or long return value | |
| 139 // The following fields are used as temps during the unpacking phase | |
| 140 // (which is tight on registers, especially on x86). They really ought | |
| 141 // to be PD variables but that involves moving this class into its own | |
| 142 // file to use the pd include mechanism. Maybe in a later cleanup ... | |
| 143 intptr_t _counter_temp; // SHOULD BE PD VARIABLE (x86 frame count temp) | |
| 144 intptr_t _initial_fp; // SHOULD BE PD VARIABLE (x86/c2 initial ebp) | |
| 145 intptr_t _unpack_kind; // SHOULD BE PD VARIABLE (x86 unpack kind) | |
| 146 intptr_t _sender_sp_temp; // SHOULD BE PD VARIABLE (x86 sender_sp) | |
| 147 public: | |
| 148 // Constructor | |
| 149 UnrollBlock(int size_of_deoptimized_frame, | |
| 150 int caller_adjustment, | |
| 151 int number_of_frames, | |
| 152 intptr_t* frame_sizes, | |
| 153 address* frames_pcs, | |
| 154 BasicType return_type); | |
| 155 ~UnrollBlock(); | |
| 156 | |
| 157 // Returns where a register is located. | |
| 158 intptr_t* value_addr_at(int register_number) const; | |
| 159 | |
| 160 // Accessors | |
| 161 intptr_t* frame_sizes() const { return _frame_sizes; } | |
| 162 int number_of_frames() const { return _number_of_frames; } | |
| 163 address* frame_pcs() const { return _frame_pcs ; } | |
| 164 | |
| 165 // Returns the total size of frames | |
| 166 int size_of_frames() const; | |
| 167 | |
| 168 // Accessors used by the code generator for the unpack stub. | |
| 169 static int size_of_deoptimized_frame_offset_in_bytes() { return offset_of(UnrollBlock, _size_of_deoptimized_frame); } | |
| 170 static int caller_adjustment_offset_in_bytes() { return offset_of(UnrollBlock, _caller_adjustment); } | |
| 171 static int number_of_frames_offset_in_bytes() { return offset_of(UnrollBlock, _number_of_frames); } | |
| 172 static int frame_sizes_offset_in_bytes() { return offset_of(UnrollBlock, _frame_sizes); } | |
| 173 static int total_frame_sizes_offset_in_bytes() { return offset_of(UnrollBlock, _total_frame_sizes); } | |
| 174 static int frame_pcs_offset_in_bytes() { return offset_of(UnrollBlock, _frame_pcs); } | |
| 175 static int register_block_offset_in_bytes() { return offset_of(UnrollBlock, _register_block); } | |
| 176 static int return_type_offset_in_bytes() { return offset_of(UnrollBlock, _return_type); } | |
| 177 static int counter_temp_offset_in_bytes() { return offset_of(UnrollBlock, _counter_temp); } | |
| 178 static int initial_fp_offset_in_bytes() { return offset_of(UnrollBlock, _initial_fp); } | |
| 179 static int unpack_kind_offset_in_bytes() { return offset_of(UnrollBlock, _unpack_kind); } | |
| 180 static int sender_sp_temp_offset_in_bytes() { return offset_of(UnrollBlock, _sender_sp_temp); } | |
| 181 | |
| 182 BasicType return_type() const { return _return_type; } | |
| 183 void print(); | |
| 184 }; | |
| 185 | |
| 186 //** Returns an UnrollBlock continuing information | |
| 187 // how to make room for the resulting interpreter frames. | |
| 188 // Called by assembly stub after execution has returned to | |
| 189 // deoptimized frame. | |
| 190 // @argument thread. Thread where stub_frame resides. | |
| 191 // @see OptoRuntime::deoptimization_fetch_unroll_info_C | |
| 192 static UnrollBlock* fetch_unroll_info(JavaThread* thread); | |
| 193 | |
| 194 //** Unpacks vframeArray onto execution stack | |
| 195 // Called by assembly stub after execution has returned to | |
| 196 // deoptimized frame and after the stack unrolling. | |
| 197 // @argument thread. Thread where stub_frame resides. | |
| 198 // @argument exec_mode. Determines how execution should be continuted in top frame. | |
| 199 // 0 means continue after current byte code | |
| 200 // 1 means exception has happened, handle exception | |
| 201 // 2 means reexecute current bytecode (for uncommon traps). | |
| 202 // @see OptoRuntime::deoptimization_unpack_frames_C | |
| 203 // Return BasicType of call return type, if any | |
| 204 static BasicType unpack_frames(JavaThread* thread, int exec_mode); | |
| 205 | |
| 206 // Cleans up deoptimization bits on thread after unpacking or in the | |
| 207 // case of an exception. | |
| 208 static void cleanup_deopt_info(JavaThread *thread, | |
| 209 vframeArray * array); | |
| 210 | |
| 211 // Restores callee saved values from deoptimized frame into oldest interpreter frame | |
| 212 // so caller of the deoptimized frame will get back the values it expects. | |
| 213 static void unwind_callee_save_values(frame* f, vframeArray* vframe_array); | |
| 214 | |
| 215 //** Performs an uncommon trap for compiled code. | |
| 216 // The top most compiler frame is converted into interpreter frames | |
| 217 static UnrollBlock* uncommon_trap(JavaThread* thread, jint unloaded_class_index); | |
| 218 // Helper routine that enters the VM and may block | |
| 219 static void uncommon_trap_inner(JavaThread* thread, jint unloaded_class_index); | |
| 220 | |
| 221 //** Deoptimizes the frame identified by id. | |
| 222 // Only called from VMDeoptimizeFrame | |
| 223 // @argument thread. Thread where stub_frame resides. | |
| 224 // @argument id. id of frame that should be deoptimized. | |
|
1905
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1783
diff
changeset
|
225 static void deoptimize_frame_internal(JavaThread* thread, intptr_t* id); |
|
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1783
diff
changeset
|
226 |
|
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1783
diff
changeset
|
227 // If thread is not the current thread then execute |
|
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1783
diff
changeset
|
228 // VM_DeoptimizeFrame otherwise deoptimize directly. |
| 0 | 229 static void deoptimize_frame(JavaThread* thread, intptr_t* id); |
| 230 | |
| 231 // Statistics | |
| 232 static void gather_statistics(DeoptReason reason, DeoptAction action, | |
| 233 Bytecodes::Code bc = Bytecodes::_illegal); | |
| 234 static void print_statistics(); | |
| 235 | |
| 236 // How much room to adjust the last frame's SP by, to make space for | |
| 237 // the callee's interpreter frame (which expects locals to be next to | |
| 238 // incoming arguments) | |
| 239 static int last_frame_adjust(int callee_parameters, int callee_locals); | |
| 240 | |
| 241 // trap_request codes | |
| 242 static DeoptReason trap_request_reason(int trap_request) { | |
| 243 if (trap_request < 0) | |
| 244 return (DeoptReason) | |
| 245 ((~(trap_request) >> _reason_shift) & right_n_bits(_reason_bits)); | |
| 246 else | |
| 247 // standard reason for unloaded CP entry | |
| 248 return Reason_unloaded; | |
| 249 } | |
| 250 static DeoptAction trap_request_action(int trap_request) { | |
| 251 if (trap_request < 0) | |
| 252 return (DeoptAction) | |
| 253 ((~(trap_request) >> _action_shift) & right_n_bits(_action_bits)); | |
| 254 else | |
| 255 // standard action for unloaded CP entry | |
| 256 return _unloaded_action; | |
| 257 } | |
| 258 static int trap_request_index(int trap_request) { | |
| 259 if (trap_request < 0) | |
| 260 return -1; | |
| 261 else | |
| 262 return trap_request; | |
| 263 } | |
| 264 static int make_trap_request(DeoptReason reason, DeoptAction action, | |
| 265 int index = -1) { | |
| 266 assert((1 << _reason_bits) >= Reason_LIMIT, "enough bits"); | |
| 267 assert((1 << _action_bits) >= Action_LIMIT, "enough bits"); | |
| 268 int trap_request; | |
| 269 if (index != -1) | |
| 270 trap_request = index; | |
| 271 else | |
| 272 trap_request = (~(((reason) << _reason_shift) | |
| 273 + ((action) << _action_shift))); | |
| 274 assert(reason == trap_request_reason(trap_request), "valid reason"); | |
| 275 assert(action == trap_request_action(trap_request), "valid action"); | |
| 276 assert(index == trap_request_index(trap_request), "valid index"); | |
| 277 return trap_request; | |
| 278 } | |
| 279 | |
| 280 // The trap_state stored in a MDO is decoded here. | |
| 281 // It records two items of information. | |
| 282 // reason: If a deoptimization happened here, what its reason was, | |
| 283 // or if there were multiple deopts with differing reasons. | |
| 284 // recompiled: If a deoptimization here triggered a recompilation. | |
| 285 // Note that not all reasons are recorded per-bci. | |
| 286 static DeoptReason trap_state_reason(int trap_state); | |
| 287 static int trap_state_has_reason(int trap_state, int reason); | |
| 288 static int trap_state_add_reason(int trap_state, int reason); | |
| 289 static bool trap_state_is_recompiled(int trap_state); | |
| 290 static int trap_state_set_recompiled(int trap_state, bool z); | |
| 291 static const char* format_trap_state(char* buf, size_t buflen, | |
| 292 int trap_state); | |
| 293 | |
| 294 static bool reason_is_recorded_per_bytecode(DeoptReason reason) { | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1172
diff
changeset
|
295 return reason > Reason_none && reason <= Reason_RECORDED_LIMIT; |
| 0 | 296 } |
| 297 | |
| 298 static DeoptReason reason_recorded_per_bytecode_if_any(DeoptReason reason) { | |
| 299 if (reason_is_recorded_per_bytecode(reason)) | |
| 300 return reason; | |
| 301 else if (reason == Reason_div0_check) // null check due to divide-by-zero? | |
| 302 return Reason_null_check; // recorded per BCI as a null check | |
| 303 else | |
| 304 return Reason_none; | |
| 305 } | |
| 306 | |
| 307 static const char* trap_reason_name(int reason); | |
| 308 static const char* trap_action_name(int action); | |
| 309 // Format like reason='foo' action='bar' index='123'. | |
| 310 // This is suitable both for XML and for tty output. | |
| 311 static const char* format_trap_request(char* buf, size_t buflen, | |
| 312 int trap_request); | |
| 313 | |
| 314 static jint total_deoptimization_count(); | |
| 315 static jint deoptimization_count(DeoptReason reason); | |
| 316 | |
| 317 // JVMTI PopFrame support | |
| 318 | |
| 319 // Preserves incoming arguments to the popped frame when it is | |
| 320 // returning to a deoptimized caller | |
| 321 static void popframe_preserve_args(JavaThread* thread, int bytes_to_save, void* start_address); | |
| 322 | |
| 323 private: | |
| 324 static methodDataOop get_method_data(JavaThread* thread, methodHandle m, bool create_if_missing); | |
| 325 // Update the mdo's count and per-BCI reason bits, returning previous state: | |
| 326 static ProfileData* query_update_method_data(methodDataHandle trap_mdo, | |
| 327 int trap_bci, | |
| 328 DeoptReason reason, | |
| 329 //outputs: | |
| 330 uint& ret_this_trap_count, | |
| 331 bool& ret_maybe_prior_trap, | |
| 332 bool& ret_maybe_prior_recompile); | |
| 333 // class loading support for uncommon trap | |
| 334 static void load_class_by_index(constantPoolHandle constant_pool, int index, TRAPS); | |
| 335 static void load_class_by_index(constantPoolHandle constant_pool, int index); | |
| 336 | |
| 337 static UnrollBlock* fetch_unroll_info_helper(JavaThread* thread); | |
| 338 | |
| 339 static DeoptAction _unloaded_action; // == Action_reinterpret; | |
| 340 static const char* _trap_reason_name[Reason_LIMIT]; | |
| 341 static const char* _trap_action_name[Action_LIMIT]; | |
| 342 | |
| 343 static juint _deoptimization_hist[Reason_LIMIT][1+Action_LIMIT][BC_CASE_LIMIT]; | |
| 344 // Note: Histogram array size is 1-2 Kb. | |
| 345 | |
| 346 public: | |
| 347 static void update_method_data_from_interpreter(methodDataHandle trap_mdo, int trap_bci, int reason); | |
| 348 }; | |
| 349 | |
| 350 class DeoptimizationMarker : StackObj { // for profiling | |
| 351 static bool _is_active; | |
| 352 public: | |
| 353 DeoptimizationMarker() { _is_active = true; } | |
| 354 ~DeoptimizationMarker() { _is_active = false; } | |
| 355 static bool is_active() { return _is_active; } | |
| 356 }; | |
| 1972 | 357 |
| 358 #endif // SHARE_VM_RUNTIME_DEOPTIMIZATION_HPP |