26 #define SHARE_VM_COMPILER_COMPILEBROKER_HPP

    26 #define SHARE_VM_COMPILER_COMPILEBROKER_HPP

    27 

    27 

    28 #include "ci/compilerInterface.hpp"

    28 #include "ci/compilerInterface.hpp"

    29 #include "compiler/abstractCompiler.hpp"

    29 #include "compiler/abstractCompiler.hpp"

    30 #include "compiler/compileTask.hpp"

    30 #include "compiler/compileTask.hpp"

    31 #include "runtime/perfData.hpp"

    32 #include "runtime/perfData.hpp"

    32 #include "trace/tracing.hpp"

    33 #include "trace/tracing.hpp"

    33 

    35 

    34 class nmethod;

    36 class nmethod;

    35 class nmethodLocker;

    37 class nmethodLocker;

    36 

    38 

    37 // CompilerCounters

    39 // CompilerCounters

   127 public:

   129 public:

   128   CompileTaskWrapper(CompileTask* task);

   130   CompileTaskWrapper(CompileTask* task);

   129   ~CompileTaskWrapper();

   131   ~CompileTaskWrapper();

   130 };

   132 };

   131 

   133 

   133 // Compilation

   134 // Compilation

   134 //

   135 //

   135 // The broker for all compilation requests.

   136 // The broker for all compilation requests.

   136 class CompileBroker: AllStatic {

   137 class CompileBroker: AllStatic {

   137  friend class Threads;

   138  friend class Threads;

   139 

   140 

   140  public:

   141  public:

   141   enum {

   142   enum {

   142     name_buffer_length = 100

   143     name_buffer_length = 100

   143   };

   144   };

   236   static void invoke_compiler_on_method(CompileTask* task);

   237   static void invoke_compiler_on_method(CompileTask* task);

   237   static void post_compile(CompilerThread* thread, CompileTask* task, EventCompilation& event, bool success, ciEnv* ci_env);

   238   static void post_compile(CompilerThread* thread, CompileTask* task, EventCompilation& event, bool success, ciEnv* ci_env);

   238   static void set_last_compile(CompilerThread *thread, methodHandle method, bool is_osr, int comp_level);

   239   static void set_last_compile(CompilerThread *thread, methodHandle method, bool is_osr, int comp_level);

   239   static void push_jni_handle_block();

   240   static void push_jni_handle_block();

   240   static void pop_jni_handle_block();

   241   static void pop_jni_handle_block();

   242   static void collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task);

   242   static void collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task);

   243 

   243 

   244   static void compile_method_base(methodHandle method,

   244   static void compile_method_base(methodHandle method,

   245                                   int osr_bci,

   245                                   int osr_bci,

   246                                   int comp_level,

   246                                   int comp_level,

   251 

   251 

   252   static CompileQueue* compile_queue(int comp_level);

   252   static CompileQueue* compile_queue(int comp_level);

   253   static bool init_compiler_runtime();

   253   static bool init_compiler_runtime();

   254   static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);

   254   static void shutdown_compiler_runtime(AbstractCompiler* comp, CompilerThread* thread);

   255 

   255 

   257   enum {

   261   enum {

   258     // The entry bci used for non-OSR compilations.

   262     // The entry bci used for non-OSR compilations.

   259     standard_entry_bci = InvocationEntryBci

   263     standard_entry_bci = InvocationEntryBci

   260   };

   264   };

   261 

   265 

   265     return NULL;

   269     return NULL;

   266   }

   270   }

   267 

   271 

   268   static bool compilation_is_in_queue(methodHandle method);

   272   static bool compilation_is_in_queue(methodHandle method);

   269   static void print_compile_queues(outputStream* st);

   273   static void print_compile_queues(outputStream* st);

   270   static int queue_size(int comp_level) {

   275   static int queue_size(int comp_level) {

   271     CompileQueue *q = compile_queue(comp_level);

   276     CompileQueue *q = compile_queue(comp_level);

   272     return q != NULL ? q->size() : 0;

   277     return q != NULL ? q->size() : 0;

   273   }

   278   }

   274   static void compilation_init();

   279   static void compilation_init();