1 /* 2 * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved. 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 25 #ifndef SHARE_COMPILER_COMPILETASK_HPP 26 #define SHARE_COMPILER_COMPILETASK_HPP 27 28 #include "ci/ciMethod.hpp" 29 #include "code/nmethod.hpp" 30 #include "compiler/compileLog.hpp" 31 #include "memory/allocation.hpp" 32 #include "utilities/xmlstream.hpp" 33 34 class CompileQueue; 35 class CompileTrainingData; 36 class DirectiveSet; 37 class SCCEntry; 38 39 JVMCI_ONLY(class JVMCICompileState;) 40 41 enum class InliningResult { SUCCESS, FAILURE }; 42 43 inline InliningResult inlining_result_of(bool success) { 44 return success ? InliningResult::SUCCESS : InliningResult::FAILURE; 45 } 46 47 // CompileTask 48 // 49 // An entry in the compile queue. It represents a pending or current 50 // compilation. 51 52 class CompileTask : public CHeapObj<mtCompiler> { 53 friend class VMStructs; 54 friend class JVMCIVMStructs; 55 56 public: 57 // Different reasons for a compilation 58 // The order is important - mapped to reason_names[] 59 enum CompileReason { 60 Reason_None, 61 Reason_InvocationCount, // Simple/StackWalk-policy 62 Reason_BackedgeCount, // Simple/StackWalk-policy 63 Reason_Tiered, // Tiered-policy 64 Reason_Replay, // ciReplay 65 Reason_Whitebox, // Whitebox API 66 Reason_MustBeCompiled, // Used for -Xcomp or AlwaysCompileLoopMethods (see CompilationPolicy::must_be_compiled()) 67 Reason_Bootstrap, // JVMCI bootstrap 68 Reason_Preload, // pre-load SC code 69 Reason_Precompile, 70 Reason_PrecompileForPreload, 71 Reason_Count 72 }; 73 74 static const char* reason_name(CompileTask::CompileReason compile_reason) { 75 static const char* reason_names[] = { 76 "no_reason", 77 "count", 78 "backedge_count", 79 "tiered", 80 "replay", 81 "whitebox", 82 "must_be_compiled", 83 "bootstrap", 84 "preload", 85 "precompile", 86 "precompile_for_preload", 87 }; 88 return reason_names[compile_reason]; 89 } 90 91 static bool reason_is_precompiled(CompileTask::CompileReason compile_reason) { 92 return (compile_reason == CompileTask::Reason_Precompile) || 93 (compile_reason == CompileTask::Reason_PrecompileForPreload); 94 } 95 96 private: 97 static CompileTask* _task_free_list; 98 Monitor* _lock; 99 int _compile_id; 100 Method* _method; 101 jobject _method_holder; 102 int _osr_bci; 103 bool _is_complete; 104 bool _is_success; 105 bool _requires_online_compilation; 106 bool _is_blocking; 107 CodeSection::csize_t _nm_content_size; 108 CodeSection::csize_t _nm_total_size; 109 CodeSection::csize_t _nm_insts_size; 110 DirectiveSet* _directive; 111 AbstractCompiler* _compiler; 112 SCCEntry* _scc_entry; 113 #if INCLUDE_JVMCI 114 bool _has_waiter; 115 // Compilation state for a blocking JVMCI compilation 116 JVMCICompileState* _blocking_jvmci_compile_state; 117 #endif 118 int _comp_level; 119 int _num_inlined_bytecodes; 120 CompileTask* _next; 121 CompileTask* _prev; 122 bool _is_free; 123 // Fields used for logging why the compilation was initiated: 124 jlong _time_created; // time when task was enqueued 125 jlong _time_queued; // time when task was enqueued 126 jlong _time_started; // time when compilation started 127 Method* _hot_method; // which method actually triggered this task 128 jobject _hot_method_holder; 129 int _hot_count; // information about its invocation counter 130 CompileReason _compile_reason; // more info about the task 131 const char* _failure_reason; 132 // Specifies if _failure_reason is on the C heap. 133 bool _failure_reason_on_C_heap; 134 CompileTrainingData* _training_data; 135 CompileQueue* _compile_queue; 136 size_t _arena_bytes; // peak size of temporary memory during compilation (e.g. node arenas) 137 138 public: 139 CompileTask() : _failure_reason(nullptr), _failure_reason_on_C_heap(false) { 140 // May hold MethodCompileQueue_lock 141 _lock = new Monitor(Mutex::safepoint-1, "CompileTask_lock"); 142 } 143 144 void initialize(int compile_id, const methodHandle& method, int osr_bci, int comp_level, 145 const methodHandle& hot_method, int hot_count, SCCEntry* scc_entry, 146 CompileTask::CompileReason compile_reason, 147 CompileQueue* compile_queue, 148 bool requires_online_compilation, bool is_blocking); 149 150 static CompileTask* allocate(); 151 static void free(CompileTask* task); 152 153 int compile_id() const { return _compile_id; } 154 Method* method() const { return _method; } 155 Method* hot_method() const { return _hot_method; } 156 int osr_bci() const { return _osr_bci; } 157 bool is_complete() const { return _is_complete; } 158 bool is_blocking() const { return _is_blocking; } 159 bool is_success() const { return _is_success; } 160 bool is_scc() const { return _scc_entry != nullptr; } 161 void clear_scc() { _scc_entry = nullptr; } 162 SCCEntry* scc_entry() { return _scc_entry; } 163 bool requires_online_compilation() const { return _requires_online_compilation; } 164 DirectiveSet* directive() const { return _directive; } 165 CompileReason compile_reason() const { return _compile_reason; } 166 CodeSection::csize_t nm_content_size() { return _nm_content_size; } 167 void set_nm_content_size(CodeSection::csize_t size) { _nm_content_size = size; } 168 CodeSection::csize_t nm_insts_size() { return _nm_insts_size; } 169 void set_nm_insts_size(CodeSection::csize_t size) { _nm_insts_size = size; } 170 CodeSection::csize_t nm_total_size() { return _nm_total_size; } 171 void set_nm_total_size(CodeSection::csize_t size) { _nm_total_size = size; } 172 bool preload() const { return (_compile_reason == Reason_Preload); } 173 bool can_become_stale() const { 174 switch (_compile_reason) { 175 case Reason_BackedgeCount: 176 case Reason_InvocationCount: 177 case Reason_Tiered: 178 return !_is_blocking; 179 default: 180 return false; 181 } 182 } 183 #if INCLUDE_JVMCI 184 bool should_wait_for_compilation() const { 185 // Wait for blocking compilation to finish. 186 switch (_compile_reason) { 187 case Reason_Replay: 188 case Reason_Whitebox: 189 case Reason_Bootstrap: 190 return _is_blocking; 191 default: 192 return false; 193 } 194 } 195 196 bool has_waiter() const { return _has_waiter; } 197 void clear_waiter() { _has_waiter = false; } 198 JVMCICompileState* blocking_jvmci_compile_state() const { return _blocking_jvmci_compile_state; } 199 void set_blocking_jvmci_compile_state(JVMCICompileState* state) { 200 _blocking_jvmci_compile_state = state; 201 } 202 #endif 203 204 bool is_precompiled() { 205 return reason_is_precompiled(compile_reason()); 206 } 207 208 Monitor* lock() const { return _lock; } 209 210 CompileQueue* compile_queue() const { return _compile_queue; } 211 212 void mark_complete() { _is_complete = true; } 213 void mark_success() { _is_success = true; } 214 void mark_queued(jlong time) { _time_queued = time; } 215 void mark_started(jlong time) { _time_started = time; } 216 217 int comp_level() { return _comp_level;} 218 void set_comp_level(int comp_level) { _comp_level = comp_level;} 219 220 AbstractCompiler* compiler() const; 221 CompileTask* select_for_compilation(); 222 223 int num_inlined_bytecodes() const { return _num_inlined_bytecodes; } 224 void set_num_inlined_bytecodes(int n) { _num_inlined_bytecodes = n; } 225 226 static CompileTask* volatile* next_ptr(CompileTask& task) { return &task._next; } 227 228 CompileTask* next() const { return _next; } 229 void set_next(CompileTask* next) { _next = next; } 230 CompileTask* prev() const { return _prev; } 231 void set_prev(CompileTask* prev) { _prev = prev; } 232 bool is_free() const { return _is_free; } 233 void set_is_free(bool val) { _is_free = val; } 234 bool is_unloaded() const; 235 236 CompileTrainingData* training_data() const { return _training_data; } 237 void set_training_data(CompileTrainingData*td) { _training_data = td; } 238 239 CompileReason compile_reason() { return _compile_reason; } 240 241 // RedefineClasses support 242 void metadata_do(MetadataClosure* f); 243 void mark_on_stack(); 244 245 void set_arena_bytes(size_t s) { _arena_bytes = s; } 246 size_t arena_bytes() const { return _arena_bytes; } 247 248 private: 249 static void print_impl(outputStream* st, Method* method, int compile_id, int comp_level, 250 bool is_osr_method = false, int osr_bci = -1, bool is_blocking = false, 251 bool is_scc = false, bool is_preload = false, 252 const char* compiler_name = nullptr, 253 const char* msg = nullptr, bool short_form = false, bool cr = true, 254 jlong time_created = 0, jlong time_queued = 0, jlong time_started = 0); 255 256 public: 257 void print(outputStream* st = tty, const char* msg = nullptr, bool short_form = false, bool cr = true); 258 void print_ul(const char* msg = nullptr); 259 static void print(outputStream* st, const nmethod* nm, const char* msg = nullptr, bool short_form = false, bool cr = true) { 260 print_impl(st, nm->method(), nm->compile_id(), nm->comp_level(), 261 nm->is_osr_method(), nm->is_osr_method() ? nm->osr_entry_bci() : -1, /*is_blocking*/ false, 262 nm->scc_entry() != nullptr, nm->preloaded(), 263 nm->compiler_name(), msg, short_form, cr); 264 } 265 static void print_ul(const nmethod* nm, const char* msg = nullptr); 266 267 static void print_inline_indent(int inline_level, outputStream* st = tty); 268 269 void print_tty(); 270 void print_line_on_error(outputStream* st, char* buf, int buflen); 271 272 void log_task(xmlStream* log); 273 void log_task_queued(); 274 void log_task_start(CompileLog* log); 275 void log_task_done(CompileLog* log); 276 277 void set_failure_reason(const char* reason, bool on_C_heap = false) { 278 _failure_reason = reason; 279 _failure_reason_on_C_heap = on_C_heap; 280 } 281 282 bool check_break_at_flags(); 283 284 static void print_inlining_inner(outputStream* st, ciMethod* method, int inline_level, int bci, InliningResult result, const char* msg = nullptr); 285 static void print_inlining_tty(ciMethod* method, int inline_level, int bci, InliningResult result, const char* msg = nullptr) { 286 print_inlining_inner(tty, method, inline_level, bci, result, msg); 287 } 288 static void print_inlining_ul(ciMethod* method, int inline_level, int bci, InliningResult result, const char* msg = nullptr); 289 }; 290 291 #endif // SHARE_COMPILER_COMPILETASK_HPP