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
25 #ifndef SHARE_RUNTIME_DEOPTIMIZATION_HPP
26 #define SHARE_RUNTIME_DEOPTIMIZATION_HPP
27
28 #include "memory/allocation.hpp"
29 #include "runtime/frame.hpp"
30
31 class ProfileData;
32 class vframeArray;
33 class MonitorInfo;
34 class MonitorValue;
35 class ObjectValue;
36 class AutoBoxObjectValue;
37 class ScopeValue;
38 class compiledVFrame;
39
40 template<class E> class GrowableArray;
41
42 class Deoptimization : AllStatic {
43 friend class VMStructs;
44
45 public:
46 // What condition caused the deoptimization?
47 enum DeoptReason {
48 Reason_many = -1, // indicates presence of several reasons
49 Reason_none = 0, // indicates absence of a relevant deopt.
50 // Next 8 reasons are recorded per bytecode in DataLayout::trap_bits.
51 // This is more complicated for JVMCI as JVMCI may deoptimize to *some* bytecode before the
52 // bytecode that actually caused the deopt (with inlining, JVMCI may even deoptimize to a
53 // bytecode in another method):
54 // - bytecode y in method b() causes deopt
55 // - JVMCI deoptimizes to bytecode x in method a()
56 // -> the deopt reason will be recorded for method a() at bytecode x
57 Reason_null_check, // saw unexpected null or zero divisor (@bci)
58 Reason_null_assert, // saw unexpected non-null or non-zero (@bci)
59 Reason_range_check, // saw unexpected array index (@bci)
60 Reason_class_check, // saw unexpected object class (@bci)
61 Reason_array_check, // saw unexpected array class (aastore @bci)
62 Reason_intrinsic, // saw unexpected operand to intrinsic (@bci)
63 Reason_bimorphic, // saw unexpected object class in bimorphic inlining (@bci)
117 Action_make_not_compilable, // invalidate the nmethod and do not compile
118 Action_LIMIT
119 // Note: Keep this enum in sync. with _trap_action_name.
120 };
121
122 enum {
123 _action_bits = 3,
124 _reason_bits = 5,
125 _debug_id_bits = 23,
126 _action_shift = 0,
127 _reason_shift = _action_shift+_action_bits,
128 _debug_id_shift = _reason_shift+_reason_bits,
129 BC_CASE_LIMIT = PRODUCT_ONLY(1) NOT_PRODUCT(4) // for _deoptimization_hist
130 };
131
132 enum UnpackType {
133 Unpack_deopt = 0, // normal deoptimization, use pc computed in unpack_vframe_on_stack
134 Unpack_exception = 1, // exception is pending
135 Unpack_uncommon_trap = 2, // redo last byte code (C2 only)
136 Unpack_reexecute = 3, // reexecute bytecode (C1 only)
137 Unpack_LIMIT = 4
138 };
139
140 // Checks all compiled methods. Invalid methods are deleted and
141 // corresponding activations are deoptimized.
142 static int deoptimize_dependents();
143
144 // Deoptimizes a frame lazily. nmethod gets patched deopt happens on return to the frame
145 static void deoptimize(JavaThread* thread, frame fr, RegisterMap *reg_map);
146 static void deoptimize(JavaThread* thread, frame fr, RegisterMap *reg_map, DeoptReason reason);
147
148 #if INCLUDE_JVMCI
149 static address deoptimize_for_missing_exception_handler(CompiledMethod* cm);
150 static oop get_cached_box(AutoBoxObjectValue* bv, frame* fr, RegisterMap* reg_map, TRAPS);
151 #endif
152
153 private:
154 // Does the actual work for deoptimizing a single frame
155 static void deoptimize_single_frame(JavaThread* thread, frame fr, DeoptReason reason);
156
157 // Helper function to revoke biases of all monitors in frame if UseBiasedLocking
158 // is enabled
159 static void revoke_biases_of_monitors(JavaThread* thread, frame fr, RegisterMap* map);
160
161 #if COMPILER2_OR_JVMCI
162 JVMCI_ONLY(public:)
163
164 // Support for restoring non-escaping objects
165 static bool realloc_objects(JavaThread* thread, frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects, TRAPS);
166 static void reassign_type_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, typeArrayOop obj, BasicType type);
167 static void reassign_object_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv, objArrayOop obj);
168 static void reassign_fields(frame* fr, RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects, bool realloc_failures, bool skip_internal);
169 static void relock_objects(GrowableArray<MonitorInfo*>* monitors, JavaThread* thread, bool realloc_failures);
170 static void pop_frames_failed_reallocs(JavaThread* thread, vframeArray* array);
171 NOT_PRODUCT(static void print_objects(GrowableArray<ScopeValue*>* objects, bool realloc_failures);)
172 #endif // COMPILER2_OR_JVMCI
173
174 public:
175 static vframeArray* create_vframeArray(JavaThread* thread, frame fr, RegisterMap *reg_map, GrowableArray<compiledVFrame*>* chunk, bool realloc_failures);
176
177 // Interface used for unpacking deoptimized frames
178
179 // UnrollBlock is returned by fetch_unroll_info() to the deoptimization handler (blob).
180 // This is only a CheapObj to ease debugging after a deopt failure
181 class UnrollBlock : public CHeapObj<mtCompiler> {
182 friend class VMStructs;
183 friend class JVMCIVMStructs;
184 private:
185 int _size_of_deoptimized_frame; // Size, in bytes, of current deoptimized frame
186 int _caller_adjustment; // Adjustment, in bytes, to caller's SP by initial interpreted frame
187 int _number_of_frames; // Number frames to unroll
188 int _total_frame_sizes; // Total of number*sizes frames
189 intptr_t* _frame_sizes; // Array of frame sizes, in bytes, for unrolling the stack
440 Method* compiled_method,
441 //outputs:
442 uint& ret_this_trap_count,
443 bool& ret_maybe_prior_trap,
444 bool& ret_maybe_prior_recompile);
445 // class loading support for uncommon trap
446 static void load_class_by_index(const constantPoolHandle& constant_pool, int index, TRAPS);
447 static void load_class_by_index(const constantPoolHandle& constant_pool, int index);
448
449 static UnrollBlock* fetch_unroll_info_helper(JavaThread* thread, int exec_mode);
450
451 static DeoptAction _unloaded_action; // == Action_reinterpret;
452 static const char* _trap_reason_name[];
453 static const char* _trap_action_name[];
454
455 static juint _deoptimization_hist[Reason_LIMIT][1+Action_LIMIT][BC_CASE_LIMIT];
456 // Note: Histogram array size is 1-2 Kb.
457
458 public:
459 static void update_method_data_from_interpreter(MethodData* trap_mdo, int trap_bci, int reason);
460 };
461
462 class DeoptimizationMarker : StackObj { // for profiling
463 static bool _is_active;
464 public:
465 DeoptimizationMarker() { _is_active = true; }
466 ~DeoptimizationMarker() { _is_active = false; }
467 static bool is_active() { return _is_active; }
468 };
469
470 #endif // SHARE_RUNTIME_DEOPTIMIZATION_HPP
|
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
25 #ifndef SHARE_RUNTIME_DEOPTIMIZATION_HPP
26 #define SHARE_RUNTIME_DEOPTIMIZATION_HPP
27
28 #include "memory/allocation.hpp"
29 #include "runtime/frame.hpp"
30
31 class ProfileData;
32 class vframeArray;
33 class MonitorInfo;
34 class MonitorValue;
35 class ObjectValue;
36 class AutoBoxObjectValue;
37 class ScopeValue;
38 class compiledVFrame;
39 class JVMTIEscapeBarrier;
40
41 template<class E> class GrowableArray;
42
43 class Deoptimization : AllStatic {
44 friend class VMStructs;
45 friend class JVMTIEscapeBarrier;
46
47 public:
48 // What condition caused the deoptimization?
49 enum DeoptReason {
50 Reason_many = -1, // indicates presence of several reasons
51 Reason_none = 0, // indicates absence of a relevant deopt.
52 // Next 8 reasons are recorded per bytecode in DataLayout::trap_bits.
53 // This is more complicated for JVMCI as JVMCI may deoptimize to *some* bytecode before the
54 // bytecode that actually caused the deopt (with inlining, JVMCI may even deoptimize to a
55 // bytecode in another method):
56 // - bytecode y in method b() causes deopt
57 // - JVMCI deoptimizes to bytecode x in method a()
58 // -> the deopt reason will be recorded for method a() at bytecode x
59 Reason_null_check, // saw unexpected null or zero divisor (@bci)
60 Reason_null_assert, // saw unexpected non-null or non-zero (@bci)
61 Reason_range_check, // saw unexpected array index (@bci)
62 Reason_class_check, // saw unexpected object class (@bci)
63 Reason_array_check, // saw unexpected array class (aastore @bci)
64 Reason_intrinsic, // saw unexpected operand to intrinsic (@bci)
65 Reason_bimorphic, // saw unexpected object class in bimorphic inlining (@bci)
119 Action_make_not_compilable, // invalidate the nmethod and do not compile
120 Action_LIMIT
121 // Note: Keep this enum in sync. with _trap_action_name.
122 };
123
124 enum {
125 _action_bits = 3,
126 _reason_bits = 5,
127 _debug_id_bits = 23,
128 _action_shift = 0,
129 _reason_shift = _action_shift+_action_bits,
130 _debug_id_shift = _reason_shift+_reason_bits,
131 BC_CASE_LIMIT = PRODUCT_ONLY(1) NOT_PRODUCT(4) // for _deoptimization_hist
132 };
133
134 enum UnpackType {
135 Unpack_deopt = 0, // normal deoptimization, use pc computed in unpack_vframe_on_stack
136 Unpack_exception = 1, // exception is pending
137 Unpack_uncommon_trap = 2, // redo last byte code (C2 only)
138 Unpack_reexecute = 3, // reexecute bytecode (C1 only)
139 Unpack_none = 4, // not deoptimizing the frame, just reallocating/relocking for JVMTI
140 Unpack_LIMIT = 5
141 };
142
143 // Checks all compiled methods. Invalid methods are deleted and
144 // corresponding activations are deoptimized.
145 static int deoptimize_dependents();
146
147 // Deoptimizes a frame lazily. nmethod gets patched deopt happens on return to the frame
148 static void deoptimize(JavaThread* thread, frame fr, RegisterMap *reg_map);
149 static void deoptimize(JavaThread* thread, frame fr, RegisterMap *reg_map, DeoptReason reason);
150
151 #if INCLUDE_JVMCI
152 static address deoptimize_for_missing_exception_handler(CompiledMethod* cm);
153 static oop get_cached_box(AutoBoxObjectValue* bv, frame* fr, const RegisterMap* reg_map, TRAPS);
154 #endif
155
156 private:
157 // Does the actual work for deoptimizing a single frame
158 static void deoptimize_single_frame(JavaThread* thread, frame fr, DeoptReason reason);
159
160 // Helper function to revoke biases of all monitors in frame if UseBiasedLocking
161 // is enabled
162 static void revoke_biases_of_monitors(JavaThread* thread, frame fr, RegisterMap* map);
163
164 #if COMPILER2_OR_JVMCI
165 // Deoptimize objects, that is reallocate and relock them. Deoptimize holding frame.
166 static bool deoptimize_objects(JavaThread* thread, GrowableArray<compiledVFrame*>* chunk, bool& realloc_failures, int exec_mode);
167
168 JVMCI_ONLY(public:)
169
170 // Support for restoring non-escaping objects
171 static bool realloc_objects(JavaThread* thread, frame* fr, const RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects, TRAPS);
172 static void reassign_type_array_elements(frame* fr, const RegisterMap* reg_map, ObjectValue* sv, typeArrayOop obj, BasicType type);
173 static void reassign_object_array_elements(frame* fr, const RegisterMap* reg_map, ObjectValue* sv, objArrayOop obj);
174 static void reassign_fields(frame* fr, const RegisterMap* reg_map, GrowableArray<ScopeValue*>* objects, bool realloc_failures, bool skip_internal);
175 static bool relock_objects(JavaThread* thread, GrowableArray<MonitorInfo*>* monitors,
176 JavaThread* deoptee_thread, frame* fr, int exec_mode, bool realloc_failures);
177 static void pop_frames_failed_reallocs(JavaThread* thread, vframeArray* array);
178 NOT_PRODUCT(static void print_objects(GrowableArray<ScopeValue*>* objects, bool realloc_failures);)
179 #endif // COMPILER2_OR_JVMCI
180
181 public:
182 static vframeArray* create_vframeArray(JavaThread* thread, frame fr, RegisterMap *reg_map, GrowableArray<compiledVFrame*>* chunk, bool realloc_failures);
183
184 // Interface used for unpacking deoptimized frames
185
186 // UnrollBlock is returned by fetch_unroll_info() to the deoptimization handler (blob).
187 // This is only a CheapObj to ease debugging after a deopt failure
188 class UnrollBlock : public CHeapObj<mtCompiler> {
189 friend class VMStructs;
190 friend class JVMCIVMStructs;
191 private:
192 int _size_of_deoptimized_frame; // Size, in bytes, of current deoptimized frame
193 int _caller_adjustment; // Adjustment, in bytes, to caller's SP by initial interpreted frame
194 int _number_of_frames; // Number frames to unroll
195 int _total_frame_sizes; // Total of number*sizes frames
196 intptr_t* _frame_sizes; // Array of frame sizes, in bytes, for unrolling the stack
447 Method* compiled_method,
448 //outputs:
449 uint& ret_this_trap_count,
450 bool& ret_maybe_prior_trap,
451 bool& ret_maybe_prior_recompile);
452 // class loading support for uncommon trap
453 static void load_class_by_index(const constantPoolHandle& constant_pool, int index, TRAPS);
454 static void load_class_by_index(const constantPoolHandle& constant_pool, int index);
455
456 static UnrollBlock* fetch_unroll_info_helper(JavaThread* thread, int exec_mode);
457
458 static DeoptAction _unloaded_action; // == Action_reinterpret;
459 static const char* _trap_reason_name[];
460 static const char* _trap_action_name[];
461
462 static juint _deoptimization_hist[Reason_LIMIT][1+Action_LIMIT][BC_CASE_LIMIT];
463 // Note: Histogram array size is 1-2 Kb.
464
465 public:
466 static void update_method_data_from_interpreter(MethodData* trap_mdo, int trap_bci, int reason);
467
468 #if defined(ASSERT) && COMPILER2_OR_JVMCI
469 // Revert optimizations based on escape analysis for all compiled frames of all Java threads.
470 static void deoptimize_objects_alot_loop();
471 #endif // defined(ASSERT) && COMPILER2_OR_JVMCI
472 };
473
474 // JVMTIEscapeBarriers should be put on execution paths, where JVMTI agents can access object
475 // references helt by java threads.
476 // They provide means to revert optimizations based on escape analysis in a well synchronized manner
477 // just before local references escape through JVMTI.
478 class JVMTIEscapeBarrier : StackObj {
479 #if COMPILER2_OR_JVMCI
480 JavaThread* const _calling_thread;
481 JavaThread* const _deoptee_thread;
482 bool const _barrier_active;
483
484 static bool _deoptimizing_objects_for_all_threads;
485 static bool _self_deoptimization_in_progress;
486
487 void sync_and_suspend_one();
488 void sync_and_suspend_all();
489 void resume_one();
490 void resume_all();
491
492 // Deoptimize the given frame and deoptimize objects with optimizations based on escape analysis.
493 bool deoptimize_objects(JavaThread* deoptee, frame fr, const RegisterMap *reg_map);
494
495 public:
496 // Revert ea based optimizations for given deoptee thread
497 JVMTIEscapeBarrier(JavaThread* calling_thread, JavaThread* deoptee_thread, bool barrier_active)
498 : _calling_thread(calling_thread), _deoptee_thread(deoptee_thread), _barrier_active(barrier_active)
499 {
500 if (_barrier_active) sync_and_suspend_one();
501 }
502
503 // Revert ea based optimizations for all java threads
504 JVMTIEscapeBarrier(JavaThread* calling_thread, bool barrier_active)
505 : _calling_thread(calling_thread), _deoptee_thread(NULL), _barrier_active(barrier_active)
506 {
507 if (_barrier_active) sync_and_suspend_all();
508 }
509 #else
510 public:
511 JVMTIEscapeBarrier(JavaThread* calling_thread, JavaThread* deoptee_thread, bool barrier_active) { }
512 JVMTIEscapeBarrier(JavaThread* calling_thread, bool barrier_active) { }
513 #endif // COMPILER2_OR_JVMCI
514
515 // Deoptimize objects, i.e. reallocate and relock them. The target frames are deoptimized.
516 // The methods return false iff at least one reallocation failed.
517 bool deoptimize_objects(compiledVFrame* cvf) NOT_COMPILER2_OR_JVMCI_RETURN_(true);
518 bool deoptimize_objects(intptr_t* fr_id) NOT_COMPILER2_OR_JVMCI_RETURN_(true);
519 bool deoptimize_objects(int depth) NOT_COMPILER2_OR_JVMCI_RETURN_(true);
520 // Find and deoptimize non escaping objects and the holding frames on all stacks.
521 bool deoptimize_objects_all_threads() NOT_COMPILER2_OR_JVMCI_RETURN_(true);
522
523 // Used to prevent that new threads pop up, until the triggering operation has completed.
524 static bool deoptimizing_objects_for_all_threads() NOT_COMPILER2_OR_JVMCI_RETURN_(false);
525 static void set_deoptimizing_objects_for_all_threads(bool v) NOT_COMPILER2_OR_JVMCI_RETURN;
526
527 #if COMPILER2_OR_JVMCI
528 // Returns true iff objects were reallocated and relocked because of access through JVMTI
529 static bool objs_are_deoptimized(JavaThread* thread, intptr_t* fr_id);
530 // Remember that objects were reallocated and relocked for the compiled frame with the given id
531 static void set_objs_are_deoptimized(JavaThread* thread, intptr_t* fr_id);
532
533 ~JVMTIEscapeBarrier() {
534 if (!barrier_active()) return;
535 if (all_threads()) {
536 resume_all();
537 } else {
538 resume_one();
539 }
540 }
541
542
543 bool all_threads() const { return _deoptee_thread == NULL; } // Should revert optimizations for all threads.
544 bool self_deopt() const { return _calling_thread == _deoptee_thread; } // Current thread deoptimizes its own objects.
545 bool barrier_active() const { return _barrier_active; } // Inactive barriers are created if no local objects can escape.
546
547 // accessors
548 JavaThread* calling_thread() const { return _calling_thread; }
549 JavaThread* deoptee_thread() const { return _deoptee_thread; }
550 #endif // COMPILER2_OR_JVMCI
551 };
552
553 class DeoptimizationMarker : StackObj { // for profiling
554 static bool _is_active;
555 public:
556 DeoptimizationMarker() { _is_active = true; }
557 ~DeoptimizationMarker() { _is_active = false; }
558 static bool is_active() { return _is_active; }
559 };
560
561 #endif // SHARE_RUNTIME_DEOPTIMIZATION_HPP
|