196 _first = NULL;
197 _last = NULL;
198 _size = 0;
199 }
200
201 const char* name() const { return _name; }
202 Monitor* lock() const { return _lock; }
203
204 void add(CompileTask* task);
205 void remove(CompileTask* task);
206 CompileTask* first() { return _first; }
207 CompileTask* last() { return _last; }
208
209 CompileTask* get();
210
211 bool is_empty() const { return _first == NULL; }
212 int size() const { return _size; }
213
214 // Redefine Classes support
215 void mark_on_stack();
216
217 void print();
218 };
219
220 // CompileTaskWrapper
221 //
222 // Assign this task to the current thread. Deallocate the task
223 // when the compilation is complete.
224 class CompileTaskWrapper : StackObj {
225 public:
226 CompileTaskWrapper(CompileTask* task);
227 ~CompileTaskWrapper();
228 };
229
230
231 // Compilation
232 //
233 // The broker for all compilation requests.
234 class CompileBroker: AllStatic {
235 friend class Threads;
236 friend class CompileTaskWrapper;
237
249
250 // This flag can be used to stop compilation or turn it back on
251 static volatile jint _should_compile_new_jobs;
252
253 // The installed compiler(s)
254 static AbstractCompiler* _compilers[2];
255
256 // These counters are used for assigning id's to each compilation
257 static uint _compilation_id;
258 static uint _osr_compilation_id;
259 static uint _native_compilation_id;
260
261 static int _last_compile_type;
262 static int _last_compile_level;
263 static char _last_method_compiled[name_buffer_length];
264
265 static CompileQueue* _c2_method_queue;
266 static CompileQueue* _c1_method_queue;
267 static CompileTask* _task_free_list;
268
269 static GrowableArray<CompilerThread*>* _method_threads;
270
271 // performance counters
272 static PerfCounter* _perf_total_compilation;
273 static PerfCounter* _perf_native_compilation;
274 static PerfCounter* _perf_osr_compilation;
275 static PerfCounter* _perf_standard_compilation;
276
277 static PerfCounter* _perf_total_bailout_count;
278 static PerfCounter* _perf_total_invalidated_count;
279 static PerfCounter* _perf_total_compile_count;
280 static PerfCounter* _perf_total_native_compile_count;
281 static PerfCounter* _perf_total_osr_compile_count;
282 static PerfCounter* _perf_total_standard_compile_count;
283
284 static PerfCounter* _perf_sum_osr_bytes_compiled;
285 static PerfCounter* _perf_sum_standard_bytes_compiled;
286 static PerfCounter* _perf_sum_nmethod_size;
287 static PerfCounter* _perf_sum_nmethod_code_size;
288
289 static PerfStringVariable* _perf_last_method;
294 static PerfVariable* _perf_last_failed_type;
295 static PerfVariable* _perf_last_invalidated_type;
296
297 // Timers and counters for generating statistics
298 static elapsedTimer _t_total_compilation;
299 static elapsedTimer _t_osr_compilation;
300 static elapsedTimer _t_standard_compilation;
301
302 static int _total_compile_count;
303 static int _total_bailout_count;
304 static int _total_invalidated_count;
305 static int _total_native_compile_count;
306 static int _total_osr_compile_count;
307 static int _total_standard_compile_count;
308 static int _sum_osr_bytes_compiled;
309 static int _sum_standard_bytes_compiled;
310 static int _sum_nmethod_size;
311 static int _sum_nmethod_code_size;
312 static long _peak_compilation_time;
313
314 static CompilerThread* make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS);
315 static void init_compiler_threads(int c1_compiler_count, int c2_compiler_count);
316 static bool compilation_is_complete (methodHandle method, int osr_bci, int comp_level);
317 static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
318 static uint assign_compile_id (methodHandle method, int osr_bci);
319 static bool is_compile_blocking (methodHandle method, int osr_bci);
320 static void preload_classes (methodHandle method, TRAPS);
321
322 static CompileTask* create_compile_task(CompileQueue* queue,
323 int compile_id,
324 methodHandle method,
325 int osr_bci,
326 int comp_level,
327 methodHandle hot_method,
328 int hot_count,
329 const char* comment,
330 bool blocking);
331 static CompileTask* allocate_task();
332 static void free_task(CompileTask* task);
333 static void wait_for_completion(CompileTask* task);
334
335 static void invoke_compiler_on_method(CompileTask* task);
336 static void set_last_compile(CompilerThread *thread, methodHandle method, bool is_osr, int comp_level);
337 static void push_jni_handle_block();
338 static void pop_jni_handle_block();
339 static bool check_break_at(methodHandle method, int compile_id, bool is_osr);
340 static void collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task);
341
342 static void compile_method_base(methodHandle method,
343 int osr_bci,
344 int comp_level,
345 methodHandle hot_method,
346 int hot_count,
347 const char* comment,
348 Thread* thread);
349 static CompileQueue* compile_queue(int comp_level) {
350 if (is_c2_compile(comp_level)) return _c2_method_queue;
351 if (is_c1_compile(comp_level)) return _c1_method_queue;
352 return NULL;
353 }
354 public:
355 enum {
356 // The entry bci used for non-OSR compilations.
357 standard_entry_bci = InvocationEntryBci
358 };
359
360 static AbstractCompiler* compiler(int comp_level) {
361 if (is_c2_compile(comp_level)) return _compilers[1]; // C2
362 if (is_c1_compile(comp_level)) return _compilers[0]; // C1
363 return NULL;
364 }
365
366 static bool compilation_is_in_queue(methodHandle method, int osr_bci);
367 static int queue_size(int comp_level) {
368 CompileQueue *q = compile_queue(comp_level);
369 return q != NULL ? q->size() : 0;
370 }
371 static void compilation_init();
372 static void init_compiler_thread_log();
373 static nmethod* compile_method(methodHandle method,
374 int osr_bci,
375 int comp_level,
376 methodHandle hot_method,
377 int hot_count,
378 const char* comment, Thread* thread);
379
380 static void compiler_thread_loop();
381
382 static uint get_compilation_id() { return _compilation_id; }
383 static bool is_idle();
384
385 // Set _should_block.
386 // Call this from the VM, with Threads_lock held and a safepoint requested.
387 static void set_should_block();
388
389 // Call this from the compiler at convenient points, to poll for _should_block.
390 static void maybe_block();
391
392 enum {
393 // Flags for toggling compiler activity
394 stop_compilation = 0,
395 run_compilation = 1
396 };
397
398 static bool should_compile_new_jobs() { return UseCompiler && (_should_compile_new_jobs == run_compilation); }
399 static bool set_should_compile_new_jobs(jint new_state) {
400 // Return success if the current caller set it
401 jint old = Atomic::cmpxchg(new_state, &_should_compile_new_jobs, 1-new_state);
402 return (old == (1-new_state));
403 }
404 static void handle_full_code_cache();
405
406 // Return total compilation ticks
407 static jlong total_compilation_ticks() {
408 return _perf_total_compilation != NULL ? _perf_total_compilation->get_value() : 0;
409 }
410
411 // Redefine Classes support
412 static void mark_on_stack();
413
414 // Print a detailed accounting of compilation time
415 static void print_times();
416
417 // Debugging output for failure
418 static void print_last_compile();
419
420 static void print_compiler_threads_on(outputStream* st);
421
422 // compiler name for debugging
|
196 _first = NULL;
197 _last = NULL;
198 _size = 0;
199 }
200
201 const char* name() const { return _name; }
202 Monitor* lock() const { return _lock; }
203
204 void add(CompileTask* task);
205 void remove(CompileTask* task);
206 CompileTask* first() { return _first; }
207 CompileTask* last() { return _last; }
208
209 CompileTask* get();
210
211 bool is_empty() const { return _first == NULL; }
212 int size() const { return _size; }
213
214 // Redefine Classes support
215 void mark_on_stack();
216 void delete_all();
217 void print();
218
219 ~CompileQueue() {
220 assert (is_empty(), " Compile Queue must be empty");
221 }
222 };
223
224 // CompileTaskWrapper
225 //
226 // Assign this task to the current thread. Deallocate the task
227 // when the compilation is complete.
228 class CompileTaskWrapper : StackObj {
229 public:
230 CompileTaskWrapper(CompileTask* task);
231 ~CompileTaskWrapper();
232 };
233
234
235 // Compilation
236 //
237 // The broker for all compilation requests.
238 class CompileBroker: AllStatic {
239 friend class Threads;
240 friend class CompileTaskWrapper;
241
253
254 // This flag can be used to stop compilation or turn it back on
255 static volatile jint _should_compile_new_jobs;
256
257 // The installed compiler(s)
258 static AbstractCompiler* _compilers[2];
259
260 // These counters are used for assigning id's to each compilation
261 static uint _compilation_id;
262 static uint _osr_compilation_id;
263 static uint _native_compilation_id;
264
265 static int _last_compile_type;
266 static int _last_compile_level;
267 static char _last_method_compiled[name_buffer_length];
268
269 static CompileQueue* _c2_method_queue;
270 static CompileQueue* _c1_method_queue;
271 static CompileTask* _task_free_list;
272
273 static GrowableArray<CompilerThread*>* _compiler_threads;
274
275 // performance counters
276 static PerfCounter* _perf_total_compilation;
277 static PerfCounter* _perf_native_compilation;
278 static PerfCounter* _perf_osr_compilation;
279 static PerfCounter* _perf_standard_compilation;
280
281 static PerfCounter* _perf_total_bailout_count;
282 static PerfCounter* _perf_total_invalidated_count;
283 static PerfCounter* _perf_total_compile_count;
284 static PerfCounter* _perf_total_native_compile_count;
285 static PerfCounter* _perf_total_osr_compile_count;
286 static PerfCounter* _perf_total_standard_compile_count;
287
288 static PerfCounter* _perf_sum_osr_bytes_compiled;
289 static PerfCounter* _perf_sum_standard_bytes_compiled;
290 static PerfCounter* _perf_sum_nmethod_size;
291 static PerfCounter* _perf_sum_nmethod_code_size;
292
293 static PerfStringVariable* _perf_last_method;
298 static PerfVariable* _perf_last_failed_type;
299 static PerfVariable* _perf_last_invalidated_type;
300
301 // Timers and counters for generating statistics
302 static elapsedTimer _t_total_compilation;
303 static elapsedTimer _t_osr_compilation;
304 static elapsedTimer _t_standard_compilation;
305
306 static int _total_compile_count;
307 static int _total_bailout_count;
308 static int _total_invalidated_count;
309 static int _total_native_compile_count;
310 static int _total_osr_compile_count;
311 static int _total_standard_compile_count;
312 static int _sum_osr_bytes_compiled;
313 static int _sum_standard_bytes_compiled;
314 static int _sum_nmethod_size;
315 static int _sum_nmethod_code_size;
316 static long _peak_compilation_time;
317
318 static CompilerThread* make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, AbstractCompiler* comp, TRAPS);
319 static void init_compiler_threads(int c1_compiler_count, int c2_compiler_count);
320 static bool compilation_is_complete (methodHandle method, int osr_bci, int comp_level);
321 static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
322 static uint assign_compile_id (methodHandle method, int osr_bci);
323 static bool is_compile_blocking (methodHandle method, int osr_bci);
324 static void preload_classes (methodHandle method, TRAPS);
325
326 static CompileTask* create_compile_task(CompileQueue* queue,
327 int compile_id,
328 methodHandle method,
329 int osr_bci,
330 int comp_level,
331 methodHandle hot_method,
332 int hot_count,
333 const char* comment,
334 bool blocking);
335 static CompileTask* allocate_task();
336 static void free_task(CompileTask* task);
337 static void wait_for_completion(CompileTask* task);
338
339 static void invoke_compiler_on_method(CompileTask* task);
340 static void set_last_compile(CompilerThread *thread, methodHandle method, bool is_osr, int comp_level);
341 static void push_jni_handle_block();
342 static void pop_jni_handle_block();
343 static bool check_break_at(methodHandle method, int compile_id, bool is_osr);
344 static void collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task);
345
346 static void compile_method_base(methodHandle method,
347 int osr_bci,
348 int comp_level,
349 methodHandle hot_method,
350 int hot_count,
351 const char* comment,
352 Thread* thread);
353 static CompileQueue* compile_queue(int comp_level) {
354 if (is_c2_compile(comp_level)) return _c2_method_queue;
355 if (is_c1_compile(comp_level)) return _c1_method_queue;
356 return NULL;
357 }
358 static bool init_compiler_runtime();
359 static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);
360
361 public:
362 enum {
363 // The entry bci used for non-OSR compilations.
364 standard_entry_bci = InvocationEntryBci
365 };
366
367 static AbstractCompiler* compiler(int comp_level) {
368 if (is_c2_compile(comp_level)) return _compilers[1]; // C2
369 if (is_c1_compile(comp_level)) return _compilers[0]; // C1
370 return NULL;
371 }
372
373 static bool compilation_is_in_queue(methodHandle method, int osr_bci);
374 static int queue_size(int comp_level) {
375 CompileQueue *q = compile_queue(comp_level);
376 return q != NULL ? q->size() : 0;
377 }
378 static void compilation_init();
379 static void init_compiler_thread_log();
380 static nmethod* compile_method(methodHandle method,
381 int osr_bci,
382 int comp_level,
383 methodHandle hot_method,
384 int hot_count,
385 const char* comment, Thread* thread);
386
387 static void compiler_thread_loop();
388 static uint get_compilation_id() { return _compilation_id; }
389
390 // Set _should_block.
391 // Call this from the VM, with Threads_lock held and a safepoint requested.
392 static void set_should_block();
393
394 // Call this from the compiler at convenient points, to poll for _should_block.
395 static void maybe_block();
396
397 enum {
398 // Flags for toggling compiler activity
399 stop_compilation = 0,
400 run_compilation = 1,
401 shutdown_compilaton = 2
402 };
403
404 static bool should_compile_new_jobs() { return UseCompiler && (_should_compile_new_jobs == run_compilation); }
405 static bool set_should_compile_new_jobs(jint new_state) {
406 // Return success if the current caller set it
407 jint old = Atomic::cmpxchg(new_state, &_should_compile_new_jobs, 1-new_state);
408 return (old == (1-new_state));
409 }
410
411 static void disable_compilation_forever() {
412 UseCompiler = false;
413 AlwaysCompileLoopMethods = false;
414 Atomic::xchg(shutdown_compilaton, &_should_compile_new_jobs);
415 }
416
417 static bool is_compilation_disabled_forever() {
418 return _should_compile_new_jobs == shutdown_compilaton;
419 }
420 static void handle_full_code_cache();
421
422 // Return total compilation ticks
423 static jlong total_compilation_ticks() {
424 return _perf_total_compilation != NULL ? _perf_total_compilation->get_value() : 0;
425 }
426
427 // Redefine Classes support
428 static void mark_on_stack();
429
430 // Print a detailed accounting of compilation time
431 static void print_times();
432
433 // Debugging output for failure
434 static void print_last_compile();
435
436 static void print_compiler_threads_on(outputStream* st);
437
438 // compiler name for debugging
|