src/share/vm/compiler/compileBroker.hpp

Print this page




 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