src/share/vm/compiler/compileBroker.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/compiler

src/share/vm/compiler/compileBroker.hpp

Print this page
rev 9032 : 8137167: JEP165: Compiler Control: Implementation task
Summary: Compiler Control JEP
Reviewed-by: roland, twisti


  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_VM_COMPILER_COMPILEBROKER_HPP
  26 #define SHARE_VM_COMPILER_COMPILEBROKER_HPP
  27 
  28 #include "ci/compilerInterface.hpp"
  29 #include "compiler/abstractCompiler.hpp"
  30 #include "compiler/compileTask.hpp"

  31 #include "runtime/perfData.hpp"

  32 
  33 class nmethod;
  34 class nmethodLocker;
  35 
  36 // CompilerCounters
  37 //
  38 // Per Compiler Performance Counters.
  39 //
  40 class CompilerCounters : public CHeapObj<mtCompiler> {
  41 
  42   public:
  43     enum {
  44       cmname_buffer_length = 160
  45     };
  46 
  47   private:
  48 
  49     char _current_method[cmname_buffer_length];
  50     PerfStringVariable* _perf_current_method;
  51 


 121   void mark_on_stack();
 122   void free_all();
 123   void print_tty();
 124   void print(outputStream* st = tty);
 125 
 126   ~CompileQueue() {
 127     assert (is_empty(), " Compile Queue must be empty");
 128   }
 129 };
 130 
 131 // CompileTaskWrapper
 132 //
 133 // Assign this task to the current thread.  Deallocate the task
 134 // when the compilation is complete.
 135 class CompileTaskWrapper : StackObj {
 136 public:
 137   CompileTaskWrapper(CompileTask* task);
 138   ~CompileTaskWrapper();
 139 };
 140 
 141 
 142 // Compilation
 143 //
 144 // The broker for all compilation requests.
 145 class CompileBroker: AllStatic {
 146  friend class Threads;
 147   friend class CompileTaskWrapper;
 148 
 149  public:
 150   enum {
 151     name_buffer_length = 100
 152   };
 153 
 154   // Compile type Information for print_last_compile() and CompilerCounters
 155   enum { no_compile, normal_compile, osr_compile, native_compile };
 156   static int assign_compile_id (methodHandle method, int osr_bci);
 157 
 158 
 159  private:
 160   static bool _initialized;
 161   static volatile bool _should_block;


 229   static bool compilation_is_complete  (methodHandle method, int osr_bci, int comp_level);
 230   static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
 231   static bool is_compile_blocking();
 232   static void preload_classes          (methodHandle method, TRAPS);
 233 
 234   static CompileTask* create_compile_task(CompileQueue* queue,
 235                                           int           compile_id,
 236                                           methodHandle  method,
 237                                           int           osr_bci,
 238                                           int           comp_level,
 239                                           methodHandle  hot_method,
 240                                           int           hot_count,
 241                                           const char*   comment,
 242                                           bool          blocking);
 243   static void wait_for_completion(CompileTask* task);
 244 
 245   static void invoke_compiler_on_method(CompileTask* task);
 246   static void set_last_compile(CompilerThread *thread, methodHandle method, bool is_osr, int comp_level);
 247   static void push_jni_handle_block();
 248   static void pop_jni_handle_block();
 249   static bool check_break_at(methodHandle method, int compile_id, bool is_osr);
 250   static void collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task);
 251 
 252   static void compile_method_base(methodHandle method,
 253                                   int osr_bci,
 254                                   int comp_level,
 255                                   methodHandle hot_method,
 256                                   int hot_count,
 257                                   const char* comment,
 258                                   Thread* thread);
 259 
 260   static CompileQueue* compile_queue(int comp_level);
 261   static bool init_compiler_runtime();
 262   static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);
 263 
 264  public:




 265   enum {
 266     // The entry bci used for non-OSR compilations.
 267     standard_entry_bci = InvocationEntryBci
 268   };
 269 
 270   static AbstractCompiler* compiler(int comp_level) {
 271     if (is_c2_compile(comp_level)) return _compilers[1]; // C2
 272     if (is_c1_compile(comp_level)) return _compilers[0]; // C1
 273     return NULL;
 274   }
 275 
 276   static bool compilation_is_in_queue(methodHandle method);
 277   static void print_compile_queues(outputStream* st);

 278   static int queue_size(int comp_level) {
 279     CompileQueue *q = compile_queue(comp_level);
 280     return q != NULL ? q->size() : 0;
 281   }
 282   static void compilation_init();
 283   static void init_compiler_thread_log();
 284   static nmethod* compile_method(methodHandle method,
 285                                  int osr_bci,
 286                                  int comp_level,
 287                                  methodHandle hot_method,
 288                                  int hot_count,
 289                                  const char* comment, Thread* thread);
 290 
 291   static void compiler_thread_loop();
 292   static uint get_compilation_id() { return _compilation_id; }
 293 
 294   // Set _should_block.
 295   // Call this from the VM, with Threads_lock held and a safepoint requested.
 296   static void set_should_block();
 297 




  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_VM_COMPILER_COMPILEBROKER_HPP
  26 #define SHARE_VM_COMPILER_COMPILEBROKER_HPP
  27 
  28 #include "ci/compilerInterface.hpp"
  29 #include "compiler/abstractCompiler.hpp"
  30 #include "compiler/compileTask.hpp"
  31 #include "compiler/compilerDirectives.hpp"
  32 #include "runtime/perfData.hpp"
  33 #include "utilities/stack.hpp"
  34 
  35 class nmethod;
  36 class nmethodLocker;
  37 
  38 // CompilerCounters
  39 //
  40 // Per Compiler Performance Counters.
  41 //
  42 class CompilerCounters : public CHeapObj<mtCompiler> {
  43 
  44   public:
  45     enum {
  46       cmname_buffer_length = 160
  47     };
  48 
  49   private:
  50 
  51     char _current_method[cmname_buffer_length];
  52     PerfStringVariable* _perf_current_method;
  53 


 123   void mark_on_stack();
 124   void free_all();
 125   void print_tty();
 126   void print(outputStream* st = tty);
 127 
 128   ~CompileQueue() {
 129     assert (is_empty(), " Compile Queue must be empty");
 130   }
 131 };
 132 
 133 // CompileTaskWrapper
 134 //
 135 // Assign this task to the current thread.  Deallocate the task
 136 // when the compilation is complete.
 137 class CompileTaskWrapper : StackObj {
 138 public:
 139   CompileTaskWrapper(CompileTask* task);
 140   ~CompileTaskWrapper();
 141 };
 142 

 143 // Compilation
 144 //
 145 // The broker for all compilation requests.
 146 class CompileBroker: AllStatic {
 147  friend class Threads;
 148  friend class CompileTaskWrapper;
 149 
 150  public:
 151   enum {
 152     name_buffer_length = 100
 153   };
 154 
 155   // Compile type Information for print_last_compile() and CompilerCounters
 156   enum { no_compile, normal_compile, osr_compile, native_compile };
 157   static int assign_compile_id (methodHandle method, int osr_bci);
 158 
 159 
 160  private:
 161   static bool _initialized;
 162   static volatile bool _should_block;


 230   static bool compilation_is_complete  (methodHandle method, int osr_bci, int comp_level);
 231   static bool compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level);
 232   static bool is_compile_blocking();
 233   static void preload_classes          (methodHandle method, TRAPS);
 234 
 235   static CompileTask* create_compile_task(CompileQueue* queue,
 236                                           int           compile_id,
 237                                           methodHandle  method,
 238                                           int           osr_bci,
 239                                           int           comp_level,
 240                                           methodHandle  hot_method,
 241                                           int           hot_count,
 242                                           const char*   comment,
 243                                           bool          blocking);
 244   static void wait_for_completion(CompileTask* task);
 245 
 246   static void invoke_compiler_on_method(CompileTask* task);
 247   static void set_last_compile(CompilerThread *thread, methodHandle method, bool is_osr, int comp_level);
 248   static void push_jni_handle_block();
 249   static void pop_jni_handle_block();

 250   static void collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task);
 251 
 252   static void compile_method_base(methodHandle method,
 253                                   int osr_bci,
 254                                   int comp_level,
 255                                   methodHandle hot_method,
 256                                   int hot_count,
 257                                   const char* comment,
 258                                   Thread* thread);
 259 
 260   static CompileQueue* compile_queue(int comp_level);
 261   static bool init_compiler_runtime();
 262   static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);
 263 
 264 public:
 265 
 266   static DirectivesStack* dirstack();
 267   static void set_dirstack(DirectivesStack* stack);
 268 
 269   enum {
 270     // The entry bci used for non-OSR compilations.
 271     standard_entry_bci = InvocationEntryBci
 272   };
 273 
 274   static AbstractCompiler* compiler(int comp_level) {
 275     if (is_c2_compile(comp_level)) return _compilers[1]; // C2
 276     if (is_c1_compile(comp_level)) return _compilers[0]; // C1
 277     return NULL;
 278   }
 279 
 280   static bool compilation_is_in_queue(methodHandle method);
 281   static void print_compile_queues(outputStream* st);
 282   static void print_directives(outputStream* st);
 283   static int queue_size(int comp_level) {
 284     CompileQueue *q = compile_queue(comp_level);
 285     return q != NULL ? q->size() : 0;
 286   }
 287   static void compilation_init();
 288   static void init_compiler_thread_log();
 289   static nmethod* compile_method(methodHandle method,
 290                                  int osr_bci,
 291                                  int comp_level,
 292                                  methodHandle hot_method,
 293                                  int hot_count,
 294                                  const char* comment, Thread* thread);
 295 
 296   static void compiler_thread_loop();
 297   static uint get_compilation_id() { return _compilation_id; }
 298 
 299   // Set _should_block.
 300   // Call this from the VM, with Threads_lock held and a safepoint requested.
 301   static void set_should_block();
 302 


src/share/vm/compiler/compileBroker.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File