src/share/vm/compiler/compileBroker.hpp

Print this page




 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   }




 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*>* _compiler_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, AbstractCompiler* comp, 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   static bool init_compiler_runtime();
 355 
 356  public:
 357   enum {
 358     // The entry bci used for non-OSR compilations.
 359     standard_entry_bci = InvocationEntryBci
 360   };
 361 
 362   static AbstractCompiler* compiler(int comp_level) {
 363     if (is_c2_compile(comp_level)) return _compilers[1]; // C2
 364     if (is_c1_compile(comp_level)) return _compilers[0]; // C1
 365     return NULL;
 366   }
 367 
 368   static bool compilation_is_in_queue(methodHandle method, int osr_bci);
 369   static int queue_size(int comp_level) {
 370     CompileQueue *q = compile_queue(comp_level);
 371     return q != NULL ? q->size() : 0;
 372   }
 373   static void compilation_init();
 374   static void init_compiler_thread_log();
 375   static nmethod* compile_method(methodHandle method,
 376                                  int osr_bci,
 377                                  int comp_level,
 378                                  methodHandle hot_method,
 379                                  int hot_count,
 380                                  const char* comment, Thread* thread);
 381 
 382   static void compiler_thread_loop();

 383   static uint get_compilation_id() { return _compilation_id; }

 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   }