jdk8-mips64-public/hotspot: src/share/vm/compiler/compileBroker.cpp@2f644f85485d

6961690: load oops from constant table on SPARC
Summary: oops should be loaded from the constant table of an nmethod instead of materializing them with a long code sequence.
Reviewed-by: never, kvn

     1 /*

     2  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    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  */

    25 #include "precompiled.hpp"

    26 #include "classfile/systemDictionary.hpp"

    27 #include "classfile/vmSymbols.hpp"

    28 #include "code/codeCache.hpp"

    29 #include "compiler/compileBroker.hpp"

    30 #include "compiler/compileLog.hpp"

    31 #include "compiler/compilerOracle.hpp"

    32 #include "interpreter/linkResolver.hpp"

    33 #include "memory/allocation.inline.hpp"

    34 #include "oops/methodDataOop.hpp"

    35 #include "oops/methodOop.hpp"

    36 #include "oops/oop.inline.hpp"

    37 #include "prims/nativeLookup.hpp"

    38 #include "runtime/arguments.hpp"

    39 #include "runtime/compilationPolicy.hpp"

    40 #include "runtime/init.hpp"

    41 #include "runtime/interfaceSupport.hpp"

    42 #include "runtime/javaCalls.hpp"

    43 #include "runtime/os.hpp"

    44 #include "runtime/sharedRuntime.hpp"

    45 #include "runtime/sweeper.hpp"

    46 #include "utilities/dtrace.hpp"

    47 #ifdef COMPILER1

    48 #include "c1/c1_Compiler.hpp"

    49 #endif

    50 #ifdef COMPILER2

    51 #include "opto/c2compiler.hpp"

    52 #endif

    53 #ifdef SHARK

    54 #include "shark/sharkCompiler.hpp"

    55 #endif

    57 #ifdef DTRACE_ENABLED

    59 // Only bother with this argument setup if dtrace is available

    61 HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin,

    62   char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t);

    63 HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end,

    64   char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t, bool);

    66 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)              \

    67   {                                                                      \

    68     char* comp_name = (char*)(compiler)->name();                         \

    69     symbolOop klass_name = (method)->klass_name();                       \

    70     symbolOop name = (method)->name();                                   \

    71     symbolOop signature = (method)->signature();                         \

    72     HS_DTRACE_PROBE8(hotspot, method__compile__begin,                    \

    73       comp_name, strlen(comp_name),                                      \

    74       klass_name->bytes(), klass_name->utf8_length(),                    \

    75       name->bytes(), name->utf8_length(),                                \

    76       signature->bytes(), signature->utf8_length());                     \

    77   }

    79 #define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)       \

    80   {                                                                      \

    81     char* comp_name = (char*)(compiler)->name();                         \

    82     symbolOop klass_name = (method)->klass_name();                       \

    83     symbolOop name = (method)->name();                                   \

    84     symbolOop signature = (method)->signature();                         \

    85     HS_DTRACE_PROBE9(hotspot, method__compile__end,                      \

    86       comp_name, strlen(comp_name),                                      \

    87       klass_name->bytes(), klass_name->utf8_length(),                    \

    88       name->bytes(), name->utf8_length(),                                \

    89       signature->bytes(), signature->utf8_length(), (success));          \

    90   }

    92 #else //  ndef DTRACE_ENABLED

    94 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)

    95 #define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)

    97 #endif // ndef DTRACE_ENABLED

    99 bool CompileBroker::_initialized = false;

   100 volatile bool CompileBroker::_should_block = false;

   101 volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;

   103 // The installed compiler(s)

   104 AbstractCompiler* CompileBroker::_compilers[2];

   106 // These counters are used for assigning id's to each compilation

   107 uint CompileBroker::_compilation_id        = 0;

   108 uint CompileBroker::_osr_compilation_id    = 0;

   110 // Debugging information

   111 int  CompileBroker::_last_compile_type     = no_compile;

   112 int  CompileBroker::_last_compile_level    = CompLevel_none;

   113 char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length];

   115 // Performance counters

   116 PerfCounter* CompileBroker::_perf_total_compilation = NULL;

   117 PerfCounter* CompileBroker::_perf_osr_compilation = NULL;

   118 PerfCounter* CompileBroker::_perf_standard_compilation = NULL;

   120 PerfCounter* CompileBroker::_perf_total_bailout_count = NULL;

   121 PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL;

   122 PerfCounter* CompileBroker::_perf_total_compile_count = NULL;

   123 PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL;

   124 PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL;

   126 PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL;

   127 PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL;

   128 PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL;

   129 PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL;

   131 PerfStringVariable* CompileBroker::_perf_last_method = NULL;

   132 PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL;

   133 PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL;

   134 PerfVariable*       CompileBroker::_perf_last_compile_type = NULL;

   135 PerfVariable*       CompileBroker::_perf_last_compile_size = NULL;

   136 PerfVariable*       CompileBroker::_perf_last_failed_type = NULL;

   137 PerfVariable*       CompileBroker::_perf_last_invalidated_type = NULL;

   139 // Timers and counters for generating statistics

   140 elapsedTimer CompileBroker::_t_total_compilation;

   141 elapsedTimer CompileBroker::_t_osr_compilation;

   142 elapsedTimer CompileBroker::_t_standard_compilation;

   144 int CompileBroker::_total_bailout_count          = 0;

   145 int CompileBroker::_total_invalidated_count      = 0;

   146 int CompileBroker::_total_compile_count          = 0;

   147 int CompileBroker::_total_osr_compile_count      = 0;

   148 int CompileBroker::_total_standard_compile_count = 0;

   150 int CompileBroker::_sum_osr_bytes_compiled       = 0;

   151 int CompileBroker::_sum_standard_bytes_compiled  = 0;

   152 int CompileBroker::_sum_nmethod_size             = 0;

   153 int CompileBroker::_sum_nmethod_code_size        = 0;

   155 CompileQueue* CompileBroker::_c2_method_queue   = NULL;

   156 CompileQueue* CompileBroker::_c1_method_queue   = NULL;

   157 CompileTask*  CompileBroker::_task_free_list = NULL;

   159 GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;

   162 CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {

   163   CompilerThread* thread = CompilerThread::current();

   164   thread->set_task(task);

   165   CompileLog*     log  = thread->log();

   166   if (log != NULL)  task->log_task_start(log);

   167 }

   169 CompileTaskWrapper::~CompileTaskWrapper() {

   170   CompilerThread* thread = CompilerThread::current();

   171   CompileTask* task = thread->task();

   172   CompileLog*  log  = thread->log();

   173   if (log != NULL)  task->log_task_done(log);

   174   thread->set_task(NULL);

   175   task->set_code_handle(NULL);

   176   DEBUG_ONLY(thread->set_env((ciEnv*)badAddress));

   177   if (task->is_blocking()) {

   178     MutexLocker notifier(task->lock(), thread);

   179     task->mark_complete();

   180     // Notify the waiting thread that the compilation has completed.

   181     task->lock()->notify_all();

   182   } else {

   183     task->mark_complete();

   185     // By convention, the compiling thread is responsible for

   186     // recycling a non-blocking CompileTask.

   187     CompileBroker::free_task(task);

   188   }

   189 }

   192 // ------------------------------------------------------------------

   193 // CompileTask::initialize

   194 void CompileTask::initialize(int compile_id,

   195                              methodHandle method,

   196                              int osr_bci,

   197                              int comp_level,

   198                              methodHandle hot_method,

   199                              int hot_count,

   200                              const char* comment,

   201                              bool is_blocking) {

   202   assert(!_lock->is_locked(), "bad locking");

   204   _compile_id = compile_id;

   205   _method = JNIHandles::make_global(method);

   206   _osr_bci = osr_bci;

   207   _is_blocking = is_blocking;

   208   _comp_level = comp_level;

   209   _num_inlined_bytecodes = 0;

   211   _is_complete = false;

   212   _is_success = false;

   213   _code_handle = NULL;

   215   _hot_method = NULL;

   216   _hot_count = hot_count;

   217   _time_queued = 0;  // tidy

   218   _comment = comment;

   220   if (LogCompilation) {

   221     _time_queued = os::elapsed_counter();

   222     if (hot_method.not_null()) {

   223       if (hot_method == method) {

   224         _hot_method = _method;

   225       } else {

   226         _hot_method = JNIHandles::make_global(hot_method);

   227       }

   228     }

   229   }

   231   _next = NULL;

   232 }

   234 // ------------------------------------------------------------------

   235 // CompileTask::code/set_code

   236 nmethod* CompileTask::code() const {

   237   if (_code_handle == NULL)  return NULL;

   238   return _code_handle->code();

   239 }

   240 void CompileTask::set_code(nmethod* nm) {

   241   if (_code_handle == NULL && nm == NULL)  return;

   242   guarantee(_code_handle != NULL, "");

   243   _code_handle->set_code(nm);

   244   if (nm == NULL)  _code_handle = NULL;  // drop the handle also

   245 }

   247 // ------------------------------------------------------------------

   248 // CompileTask::free

   249 void CompileTask::free() {

   250   set_code(NULL);

   251   assert(!_lock->is_locked(), "Should not be locked when freed");

   252   if (_hot_method != NULL && _hot_method != _method) {

   253     JNIHandles::destroy_global(_hot_method);

   254   }

   255   JNIHandles::destroy_global(_method);

   256 }

   259 // ------------------------------------------------------------------

   260 // CompileTask::print

   261 void CompileTask::print() {

   262   tty->print("<CompileTask compile_id=%d ", _compile_id);

   263   tty->print("method=");

   264   ((methodOop)JNIHandles::resolve(_method))->print_name(tty);

   265   tty->print_cr(" osr_bci=%d is_blocking=%s is_complete=%s is_success=%s>",

   266              _osr_bci, bool_to_str(_is_blocking),

   267              bool_to_str(_is_complete), bool_to_str(_is_success));

   268 }

   271 void CompileTask::print_compilation(outputStream *st, methodOop method, char* method_name) {

   272   nmethod::print_compilation(st, method_name,/*title*/ NULL, method,

   273                              is_blocking(), compile_id(), osr_bci(), comp_level());

   274 }

   276 // ------------------------------------------------------------------

   277 // CompileTask::print_line_on_error

   278 //

   279 // This function is called by fatal error handler when the thread

   280 // causing troubles is a compiler thread.

   281 //

   282 // Do not grab any lock, do not allocate memory.

   283 //

   284 // Otherwise it's the same as CompileTask::print_line()

   285 //

   286 void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) {

   287   methodOop method = (methodOop)JNIHandles::resolve(_method);

   288   // print compiler name

   289   st->print("%s:", CompileBroker::compiler(comp_level())->name());

   290   char* method_name = NULL;

   291   if (method != NULL) {

   292     method_name = method->name_and_sig_as_C_string(buf, buflen);

   293   }

   294   print_compilation(st, method, method_name);

   295 }

   297 // ------------------------------------------------------------------

   298 // CompileTask::print_line

   299 void CompileTask::print_line() {

   300   Thread *thread = Thread::current();

   301   methodHandle method(thread,

   302                       (methodOop)JNIHandles::resolve(method_handle()));

   303   ResourceMark rm(thread);

   305   ttyLocker ttyl;  // keep the following output all in one block

   307   // print compiler name if requested

   308   if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler(comp_level())->name());

   309   print_compilation(tty, method(), NULL);

   310 }

   313 // ------------------------------------------------------------------

   314 // CompileTask::log_task

   315 void CompileTask::log_task(xmlStream* log) {

   316   Thread* thread = Thread::current();

   317   methodHandle method(thread,

   318                       (methodOop)JNIHandles::resolve(method_handle()));

   319   ResourceMark rm(thread);

   321   // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'>

   322   if (_compile_id != 0)   log->print(" compile_id='%d'", _compile_id);

   323   if (_osr_bci != CompileBroker::standard_entry_bci) {

   324     log->print(" compile_kind='osr'");  // same as nmethod::compile_kind

   325   } // else compile_kind='c2c'

   326   if (!method.is_null())  log->method(method);

   327   if (_osr_bci != CompileBroker::standard_entry_bci) {

   328     log->print(" osr_bci='%d'", _osr_bci);

   329   }

   330   if (_comp_level != CompLevel_highest_tier) {

   331     log->print(" level='%d'", _comp_level);

   332   }

   333   if (_is_blocking) {

   334     log->print(" blocking='1'");

   335   }

   336   log->stamp();

   337 }

   340 // ------------------------------------------------------------------

   341 // CompileTask::log_task_queued

   342 void CompileTask::log_task_queued() {

   343   Thread* thread = Thread::current();

   344   ttyLocker ttyl;

   345   ResourceMark rm(thread);

   347   xtty->begin_elem("task_queued");

   348   log_task(xtty);

   349   if (_comment != NULL) {

   350     xtty->print(" comment='%s'", _comment);

   351   }

   352   if (_hot_method != NULL) {

   353     methodHandle hot(thread,

   354                      (methodOop)JNIHandles::resolve(_hot_method));

   355     methodHandle method(thread,

   356                         (methodOop)JNIHandles::resolve(_method));

   357     if (hot() != method()) {

   358       xtty->method(hot);

   359     }

   360   }

   361   if (_hot_count != 0) {

   362     xtty->print(" hot_count='%d'", _hot_count);

   363   }

   364   xtty->end_elem();

   365 }

   368 // ------------------------------------------------------------------

   369 // CompileTask::log_task_start

   370 void CompileTask::log_task_start(CompileLog* log)   {

   371   log->begin_head("task");

   372   log_task(log);

   373   log->end_head();

   374 }

   377 // ------------------------------------------------------------------

   378 // CompileTask::log_task_done

   379 void CompileTask::log_task_done(CompileLog* log) {

   380   Thread* thread = Thread::current();

   381   methodHandle method(thread,

   382                       (methodOop)JNIHandles::resolve(method_handle()));

   383   ResourceMark rm(thread);

   385   // <task_done ... stamp='1.234'>  </task>

   386   nmethod* nm = code();

   387   log->begin_elem("task_done success='%d' nmsize='%d' count='%d'",

   388                   _is_success, nm == NULL ? 0 : nm->content_size(),

   389                   method->invocation_count());

   390   int bec = method->backedge_count();

   391   if (bec != 0)  log->print(" backedge_count='%d'", bec);

   392   // Note:  "_is_complete" is about to be set, but is not.

   393   if (_num_inlined_bytecodes != 0) {

   394     log->print(" inlined_bytes='%d'", _num_inlined_bytecodes);

   395   }

   396   log->stamp();

   397   log->end_elem();

   398   log->tail("task");

   399   log->clear_identities();   // next task will have different CI

   400   if (log->unflushed_count() > 2000) {

   401     log->flush();

   402   }

   403   log->mark_file_end();

   404 }

   408 // ------------------------------------------------------------------

   409 // CompileQueue::add

   410 //

   411 // Add a CompileTask to a CompileQueue

   412 void CompileQueue::add(CompileTask* task) {

   413   assert(lock()->owned_by_self(), "must own lock");

   415   task->set_next(NULL);

   416   task->set_prev(NULL);

   418   if (_last == NULL) {

   419     // The compile queue is empty.

   420     assert(_first == NULL, "queue is empty");

   421     _first = task;

   422     _last = task;

   423   } else {

   424     // Append the task to the queue.

   425     assert(_last->next() == NULL, "not last");

   426     _last->set_next(task);

   427     task->set_prev(_last);

   428     _last = task;

   429   }

   430   ++_size;

   432   // Mark the method as being in the compile queue.

   433   ((methodOop)JNIHandles::resolve(task->method_handle()))->set_queued_for_compilation();

   435   if (CIPrintCompileQueue) {

   436     print();

   437   }

   439   if (LogCompilation && xtty != NULL) {

   440     task->log_task_queued();

   441   }

   443   // Notify CompilerThreads that a task is available.

   444   lock()->notify_all();

   445 }

   447 // ------------------------------------------------------------------

   448 // CompileQueue::get

   449 //

   450 // Get the next CompileTask from a CompileQueue

   451 CompileTask* CompileQueue::get() {

   452   NMethodSweeper::possibly_sweep();

   454   MutexLocker locker(lock());

   455   // Wait for an available CompileTask.

   456   while (_first == NULL) {

   457     // There is no work to be done right now.  Wait.

   458     if (UseCodeCacheFlushing && (!CompileBroker::should_compile_new_jobs() || CodeCache::needs_flushing())) {

   459       // During the emergency sweeping periods, wake up and sweep occasionally

   460       bool timedout = lock()->wait(!Mutex::_no_safepoint_check_flag, NmethodSweepCheckInterval*1000);

   461       if (timedout) {

   462         MutexUnlocker ul(lock());

   463         // When otherwise not busy, run nmethod sweeping

   464         NMethodSweeper::possibly_sweep();

   465       }

   466     } else {

   467       // During normal operation no need to wake up on timer

   468       lock()->wait();

   469     }

   470   }

   471   CompileTask* task = CompilationPolicy::policy()->select_task(this);

   472   remove(task);

   473   return task;

   474 }

   476 void CompileQueue::remove(CompileTask* task)

   477 {

   478    assert(lock()->owned_by_self(), "must own lock");

   479   if (task->prev() != NULL) {

   480     task->prev()->set_next(task->next());

   481   } else {

   482     // max is the first element

   483     assert(task == _first, "Sanity");

   484     _first = task->next();

   485   }

   487   if (task->next() != NULL) {

   488     task->next()->set_prev(task->prev());

   489   } else {

   490     // max is the last element

   491     assert(task == _last, "Sanity");

   492     _last = task->prev();

   493   }

   494   --_size;

   495 }

   497 // ------------------------------------------------------------------

   498 // CompileQueue::print

   499 void CompileQueue::print() {

   500   tty->print_cr("Contents of %s", name());

   501   tty->print_cr("----------------------");

   502   CompileTask* task = _first;

   503   while (task != NULL) {

   504     task->print_line();

   505     task = task->next();

   506   }

   507   tty->print_cr("----------------------");

   508 }

   510 CompilerCounters::CompilerCounters(const char* thread_name, int instance, TRAPS) {

   512   _current_method[0] = '\0';

   513   _compile_type = CompileBroker::no_compile;

   515   if (UsePerfData) {

   516     ResourceMark rm;

   518     // create the thread instance name space string - don't create an

   519     // instance subspace if instance is -1 - keeps the adapterThread

   520     // counters  from having a ".0" namespace.

   521     const char* thread_i = (instance == -1) ? thread_name :

   522                       PerfDataManager::name_space(thread_name, instance);

   525     char* name = PerfDataManager::counter_name(thread_i, "method");

   526     _perf_current_method =

   527                PerfDataManager::create_string_variable(SUN_CI, name,

   528                                                        cmname_buffer_length,

   529                                                        _current_method, CHECK);

   531     name = PerfDataManager::counter_name(thread_i, "type");

   532     _perf_compile_type = PerfDataManager::create_variable(SUN_CI, name,

   533                                                           PerfData::U_None,

   534                                                          (jlong)_compile_type,

   535                                                           CHECK);

   537     name = PerfDataManager::counter_name(thread_i, "time");

   538     _perf_time = PerfDataManager::create_counter(SUN_CI, name,

   539                                                  PerfData::U_Ticks, CHECK);

   541     name = PerfDataManager::counter_name(thread_i, "compiles");

   542     _perf_compiles = PerfDataManager::create_counter(SUN_CI, name,

   543                                                      PerfData::U_Events, CHECK);

   544   }

   545 }

   547 // ------------------------------------------------------------------

   548 // CompileBroker::compilation_init

   549 //

   550 // Initialize the Compilation object

   551 void CompileBroker::compilation_init() {

   552   _last_method_compiled[0] = '\0';

   554 #ifndef SHARK

   555   // Set the interface to the current compiler(s).

   556   int c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple);

   557   int c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization);

   558 #ifdef COMPILER1

   559   if (c1_count > 0) {

   560     _compilers[0] = new Compiler();

   561   }

   562 #endif // COMPILER1

   564 #ifdef COMPILER2

   565   if (c2_count > 0) {

   566     _compilers[1] = new C2Compiler();

   567   }

   568 #endif // COMPILER2

   570 #else // SHARK

   571   int c1_count = 0;

   572   int c2_count = 1;

   574   _compilers[1] = new SharkCompiler();

   575 #endif // SHARK

   577   // Initialize the CompileTask free list

   578   _task_free_list = NULL;

   580   // Start the CompilerThreads

   581   init_compiler_threads(c1_count, c2_count);

   582   // totalTime performance counter is always created as it is required

   583   // by the implementation of java.lang.management.CompilationMBean.

   584   {

   585     EXCEPTION_MARK;

   586     _perf_total_compilation =

   587                  PerfDataManager::create_counter(JAVA_CI, "totalTime",

   588                                                  PerfData::U_Ticks, CHECK);

   589   }

   592   if (UsePerfData) {

   594     EXCEPTION_MARK;

   596     // create the jvmstat performance counters

   597     _perf_osr_compilation =

   598                  PerfDataManager::create_counter(SUN_CI, "osrTime",

   599                                                  PerfData::U_Ticks, CHECK);

   601     _perf_standard_compilation =

   602                  PerfDataManager::create_counter(SUN_CI, "standardTime",

   603                                                  PerfData::U_Ticks, CHECK);

   605     _perf_total_bailout_count =

   606                  PerfDataManager::create_counter(SUN_CI, "totalBailouts",

   607                                                  PerfData::U_Events, CHECK);

   609     _perf_total_invalidated_count =

   610                  PerfDataManager::create_counter(SUN_CI, "totalInvalidates",

   611                                                  PerfData::U_Events, CHECK);

   613     _perf_total_compile_count =

   614                  PerfDataManager::create_counter(SUN_CI, "totalCompiles",

   615                                                  PerfData::U_Events, CHECK);

   616     _perf_total_osr_compile_count =

   617                  PerfDataManager::create_counter(SUN_CI, "osrCompiles",

   618                                                  PerfData::U_Events, CHECK);

   620     _perf_total_standard_compile_count =

   621                  PerfDataManager::create_counter(SUN_CI, "standardCompiles",

   622                                                  PerfData::U_Events, CHECK);

   624     _perf_sum_osr_bytes_compiled =

   625                  PerfDataManager::create_counter(SUN_CI, "osrBytes",

   626                                                  PerfData::U_Bytes, CHECK);

   628     _perf_sum_standard_bytes_compiled =

   629                  PerfDataManager::create_counter(SUN_CI, "standardBytes",

   630                                                  PerfData::U_Bytes, CHECK);

   632     _perf_sum_nmethod_size =

   633                  PerfDataManager::create_counter(SUN_CI, "nmethodSize",

   634                                                  PerfData::U_Bytes, CHECK);

   636     _perf_sum_nmethod_code_size =

   637                  PerfDataManager::create_counter(SUN_CI, "nmethodCodeSize",

   638                                                  PerfData::U_Bytes, CHECK);

   640     _perf_last_method =

   641                  PerfDataManager::create_string_variable(SUN_CI, "lastMethod",

   642                                        CompilerCounters::cmname_buffer_length,

   643                                        "", CHECK);

   645     _perf_last_failed_method =

   646             PerfDataManager::create_string_variable(SUN_CI, "lastFailedMethod",

   647                                        CompilerCounters::cmname_buffer_length,

   648                                        "", CHECK);

   650     _perf_last_invalidated_method =

   651         PerfDataManager::create_string_variable(SUN_CI, "lastInvalidatedMethod",

   652                                      CompilerCounters::cmname_buffer_length,

   653                                      "", CHECK);

   655     _perf_last_compile_type =

   656              PerfDataManager::create_variable(SUN_CI, "lastType",

   657                                               PerfData::U_None,

   658                                               (jlong)CompileBroker::no_compile,

   659                                               CHECK);

   661     _perf_last_compile_size =

   662              PerfDataManager::create_variable(SUN_CI, "lastSize",

   663                                               PerfData::U_Bytes,

   664                                               (jlong)CompileBroker::no_compile,

   665                                               CHECK);

   668     _perf_last_failed_type =

   669              PerfDataManager::create_variable(SUN_CI, "lastFailedType",

   670                                               PerfData::U_None,

   671                                               (jlong)CompileBroker::no_compile,

   672                                               CHECK);

   674     _perf_last_invalidated_type =

   675          PerfDataManager::create_variable(SUN_CI, "lastInvalidatedType",

   676                                           PerfData::U_None,

   677                                           (jlong)CompileBroker::no_compile,

   678                                           CHECK);

   679   }

   681   _initialized = true;

   682 }

   686 // ------------------------------------------------------------------

   687 // CompileBroker::make_compiler_thread

   688 CompilerThread* CompileBroker::make_compiler_thread(const char* name, CompileQueue* queue, CompilerCounters* counters, TRAPS) {

   689   CompilerThread* compiler_thread = NULL;

   691   klassOop k =

   692     SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(),

   693                                       true, CHECK_0);

   694   instanceKlassHandle klass (THREAD, k);

   695   instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_0);

   696   Handle string = java_lang_String::create_from_str(name, CHECK_0);

   698   // Initialize thread_oop to put it into the system threadGroup

   699   Handle thread_group (THREAD,  Universe::system_thread_group());

   700   JavaValue result(T_VOID);

   701   JavaCalls::call_special(&result, thread_oop,

   702                        klass,

   703                        vmSymbolHandles::object_initializer_name(),

   704                        vmSymbolHandles::threadgroup_string_void_signature(),

   705                        thread_group,

   706                        string,

   707                        CHECK_0);

   709   {

   710     MutexLocker mu(Threads_lock, THREAD);

   711     compiler_thread = new CompilerThread(queue, counters);

   712     // At this point the new CompilerThread data-races with this startup

   713     // thread (which I believe is the primoridal thread and NOT the VM

   714     // thread).  This means Java bytecodes being executed at startup can

   715     // queue compile jobs which will run at whatever default priority the

   716     // newly created CompilerThread runs at.

   719     // At this point it may be possible that no osthread was created for the

   720     // JavaThread due to lack of memory. We would have to throw an exception

   721     // in that case. However, since this must work and we do not allow

   722     // exceptions anyway, check and abort if this fails.

   724     if (compiler_thread == NULL || compiler_thread->osthread() == NULL){

   725       vm_exit_during_initialization("java.lang.OutOfMemoryError",

   726                                     "unable to create new native thread");

   727     }

   729     java_lang_Thread::set_thread(thread_oop(), compiler_thread);

   731     // Note that this only sets the JavaThread _priority field, which by

   732     // definition is limited to Java priorities and not OS priorities.

   733     // The os-priority is set in the CompilerThread startup code itself

   734     java_lang_Thread::set_priority(thread_oop(), NearMaxPriority);

   735     // CLEANUP PRIORITIES: This -if- statement hids a bug whereby the compiler

   736     // threads never have their OS priority set.  The assumption here is to

   737     // enable the Performance group to do flag tuning, figure out a suitable

   738     // CompilerThreadPriority, and then remove this 'if' statement (and

   739     // comment) and unconditionally set the priority.

   741     // Compiler Threads should be at the highest Priority

   742     if ( CompilerThreadPriority != -1 )

   743       os::set_native_priority( compiler_thread, CompilerThreadPriority );

   744     else

   745       os::set_native_priority( compiler_thread, os::java_to_os_priority[NearMaxPriority]);

   747       // Note that I cannot call os::set_priority because it expects Java

   748       // priorities and I am *explicitly* using OS priorities so that it's

   749       // possible to set the compiler thread priority higher than any Java

   750       // thread.

   752     java_lang_Thread::set_daemon(thread_oop());

   754     compiler_thread->set_threadObj(thread_oop());

   755     Threads::add(compiler_thread);

   756     Thread::start(compiler_thread);

   757   }

   758   // Let go of Threads_lock before yielding

   759   os::yield(); // make sure that the compiler thread is started early (especially helpful on SOLARIS)

   761   return compiler_thread;

   762 }

   765 // ------------------------------------------------------------------

   766 // CompileBroker::init_compiler_threads

   767 //

   768 // Initialize the compilation queue

   769 void CompileBroker::init_compiler_threads(int c1_compiler_count, int c2_compiler_count) {

   770   EXCEPTION_MARK;

   771   assert(c2_compiler_count > 0 || c1_compiler_count > 0, "No compilers?");

   772   if (c2_compiler_count > 0) {

   773     _c2_method_queue  = new CompileQueue("C2MethodQueue",  MethodCompileQueue_lock);

   774   }

   775   if (c1_compiler_count > 0) {

   776     _c1_method_queue  = new CompileQueue("C1MethodQueue",  MethodCompileQueue_lock);

   777   }

   779   int compiler_count = c1_compiler_count + c2_compiler_count;

   781   _method_threads =

   782     new (ResourceObj::C_HEAP) GrowableArray<CompilerThread*>(compiler_count, true);

   784   char name_buffer[256];

   785   for (int i = 0; i < c2_compiler_count; i++) {

   786     // Create a name for our thread.

   787     sprintf(name_buffer, "C2 CompilerThread%d", i);

   788     CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);

   789     CompilerThread* new_thread = make_compiler_thread(name_buffer, _c2_method_queue, counters, CHECK);

   790     _method_threads->append(new_thread);

   791   }

   793   for (int i = c2_compiler_count; i < compiler_count; i++) {

   794     // Create a name for our thread.

   795     sprintf(name_buffer, "C1 CompilerThread%d", i);

   796     CompilerCounters* counters = new CompilerCounters("compilerThread", i, CHECK);

   797     CompilerThread* new_thread = make_compiler_thread(name_buffer, _c1_method_queue, counters, CHECK);

   798     _method_threads->append(new_thread);

   799   }

   801   if (UsePerfData) {

   802     PerfDataManager::create_constant(SUN_CI, "threads", PerfData::U_Bytes,

   803                                      compiler_count, CHECK);

   804   }

   805 }

   807 // ------------------------------------------------------------------

   808 // CompileBroker::is_idle

   809 bool CompileBroker::is_idle() {

   810   if (_c2_method_queue != NULL && !_c2_method_queue->is_empty()) {

   811     return false;

   812   } else if (_c1_method_queue != NULL && !_c1_method_queue->is_empty()) {

   813     return false;

   814   } else {

   815     int num_threads = _method_threads->length();

   816     for (int i=0; i<num_threads; i++) {

   817       if (_method_threads->at(i)->task() != NULL) {

   818         return false;

   819       }

   820     }

   822     // No pending or active compilations.

   823     return true;

   824   }

   825 }

   828 // ------------------------------------------------------------------

   829 // CompileBroker::compile_method

   830 //

   831 // Request compilation of a method.

   832 void CompileBroker::compile_method_base(methodHandle method,

   833                                         int osr_bci,

   834                                         int comp_level,

   835                                         methodHandle hot_method,

   836                                         int hot_count,

   837                                         const char* comment,

   838                                         TRAPS) {

   839   // do nothing if compiler thread(s) is not available

   840   if (!_initialized ) {

   841     return;

   842   }

   844   guarantee(!method->is_abstract(), "cannot compile abstract methods");

   845   assert(method->method_holder()->klass_part()->oop_is_instance(),

   846          "sanity check");

   847   assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(),

   848          "method holder must be initialized");

   850   if (CIPrintRequests) {

   851     tty->print("request: ");

   852     method->print_short_name(tty);

   853     if (osr_bci != InvocationEntryBci) {

   854       tty->print(" osr_bci: %d", osr_bci);

   855     }

   856     tty->print(" comment: %s count: %d", comment, hot_count);

   857     if (!hot_method.is_null()) {

   858       tty->print(" hot: ");

   859       if (hot_method() != method()) {

   860           hot_method->print_short_name(tty);

   861       } else {

   862         tty->print("yes");

   863       }

   864     }

   865     tty->cr();

   866   }

   868   // A request has been made for compilation.  Before we do any

   869   // real work, check to see if the method has been compiled

   870   // in the meantime with a definitive result.

   871   if (compilation_is_complete(method, osr_bci, comp_level)) {

   872     return;

   873   }

   876   // If this method is already in the compile queue, then

   877   // we do not block the current thread.

   878   if (compilation_is_in_queue(method, osr_bci)) {

   879     // We may want to decay our counter a bit here to prevent

   880     // multiple denied requests for compilation.  This is an

   881     // open compilation policy issue. Note: The other possibility,

   882     // in the case that this is a blocking compile request, is to have

   883     // all subsequent blocking requesters wait for completion of

   884     // ongoing compiles. Note that in this case we'll need a protocol

   885     // for freeing the associated compile tasks. [Or we could have

   886     // a single static monitor on which all these waiters sleep.]

   887     return;

   888   }

   890   // Outputs from the following MutexLocker block:

   891   CompileTask* task     = NULL;

   892   bool         blocking = false;

   893   CompileQueue* queue  = compile_queue(comp_level);

   895   // Acquire our lock.

   896   {

   897     MutexLocker locker(queue->lock(), THREAD);

   899     // Make sure the method has not slipped into the queues since

   900     // last we checked; note that those checks were "fast bail-outs".

   901     // Here we need to be more careful, see 14012000 below.

   902     if (compilation_is_in_queue(method, osr_bci)) {

   903       return;

   904     }

   906     // We need to check again to see if the compilation has

   907     // completed.  A previous compilation may have registered

   908     // some result.

   909     if (compilation_is_complete(method, osr_bci, comp_level)) {

   910       return;

   911     }

   913     // We now know that this compilation is not pending, complete,

   914     // or prohibited.  Assign a compile_id to this compilation

   915     // and check to see if it is in our [Start..Stop) range.

   916     uint compile_id = assign_compile_id(method, osr_bci);

   917     if (compile_id == 0) {

   918       // The compilation falls outside the allowed range.

   919       return;

   920     }

   922     // Should this thread wait for completion of the compile?

   923     blocking = is_compile_blocking(method, osr_bci);

   925     // We will enter the compilation in the queue.

   926     // 14012000: Note that this sets the queued_for_compile bits in

   927     // the target method. We can now reason that a method cannot be

   928     // queued for compilation more than once, as follows:

   929     // Before a thread queues a task for compilation, it first acquires

   930     // the compile queue lock, then checks if the method's queued bits

   931     // are set or it has already been compiled. Thus there can not be two

   932     // instances of a compilation task for the same method on the

   933     // compilation queue. Consider now the case where the compilation

   934     // thread has already removed a task for that method from the queue

   935     // and is in the midst of compiling it. In this case, the

   936     // queued_for_compile bits must be set in the method (and these

   937     // will be visible to the current thread, since the bits were set

   938     // under protection of the compile queue lock, which we hold now.

   939     // When the compilation completes, the compiler thread first sets

   940     // the compilation result and then clears the queued_for_compile

   941     // bits. Neither of these actions are protected by a barrier (or done

   942     // under the protection of a lock), so the only guarantee we have

   943     // (on machines with TSO (Total Store Order)) is that these values

   944     // will update in that order. As a result, the only combinations of

   945     // these bits that the current thread will see are, in temporal order:

   946     // <RESULT, QUEUE> :

   947     //     <0, 1> : in compile queue, but not yet compiled

   948     //     <1, 1> : compiled but queue bit not cleared

   949     //     <1, 0> : compiled and queue bit cleared

   950     // Because we first check the queue bits then check the result bits,

   951     // we are assured that we cannot introduce a duplicate task.

   952     // Note that if we did the tests in the reverse order (i.e. check

   953     // result then check queued bit), we could get the result bit before

   954     // the compilation completed, and the queue bit after the compilation

   955     // completed, and end up introducing a "duplicate" (redundant) task.

   956     // In that case, the compiler thread should first check if a method

   957     // has already been compiled before trying to compile it.

   958     // NOTE: in the event that there are multiple compiler threads and

   959     // there is de-optimization/recompilation, things will get hairy,

   960     // and in that case it's best to protect both the testing (here) of

   961     // these bits, and their updating (here and elsewhere) under a

   962     // common lock.

   963     task = create_compile_task(queue,

   964                                compile_id, method,

   965                                osr_bci, comp_level,

   966                                hot_method, hot_count, comment,

   967                                blocking);

   968   }

   970   if (blocking) {

   971     wait_for_completion(task);

   972   }

   973 }

   976 nmethod* CompileBroker::compile_method(methodHandle method, int osr_bci,

   977                                        int comp_level,

   978                                        methodHandle hot_method, int hot_count,

   979                                        const char* comment, TRAPS) {

   980   // make sure arguments make sense

   981   assert(method->method_holder()->klass_part()->oop_is_instance(), "not an instance method");

   982   assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range");

   983   assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods");

   984   assert(!instanceKlass::cast(method->method_holder())->is_not_initialized(), "method holder must be initialized");

   986   if (!TieredCompilation) {

   987     comp_level = CompLevel_highest_tier;

   988   }

   990   // return quickly if possible

   992   // lock, make sure that the compilation

   993   // isn't prohibited in a straightforward way.

   995   if (compiler(comp_level) == NULL || compilation_is_prohibited(method, osr_bci, comp_level)) {

   996     return NULL;

   997   }

   999   if (osr_bci == InvocationEntryBci) {

  1000     // standard compilation

  1001     nmethod* method_code = method->code();

  1002     if (method_code != NULL) {

  1003       if (compilation_is_complete(method, osr_bci, comp_level)) {

  1004         return method_code;

  1005       }

  1006     }

  1007     if (method->is_not_compilable(comp_level)) return NULL;

  1009     if (UseCodeCacheFlushing) {

  1010       nmethod* saved = CodeCache::find_and_remove_saved_code(method());

  1011       if (saved != NULL) {

  1012         method->set_code(method, saved);

  1013         return saved;

  1014       }

  1015     }

  1017   } else {

  1018     // osr compilation

  1019 #ifndef TIERED

  1020     // seems like an assert of dubious value

  1021     assert(comp_level == CompLevel_highest_tier,

  1022            "all OSR compiles are assumed to be at a single compilation lavel");

  1023 #endif // TIERED

  1024     // We accept a higher level osr method

  1025     nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false);

  1026     if (nm != NULL) return nm;

  1027     if (method->is_not_osr_compilable()) return NULL;

  1028   }

  1030   assert(!HAS_PENDING_EXCEPTION, "No exception should be present");

  1031   // some prerequisites that are compiler specific

  1032   if (compiler(comp_level)->is_c2()) {

  1033     method->constants()->resolve_string_constants(CHECK_0);

  1034     // Resolve all classes seen in the signature of the method

  1035     // we are compiling.

  1036     methodOopDesc::load_signature_classes(method, CHECK_0);

  1037   }

  1039   // If the method is native, do the lookup in the thread requesting

  1040   // the compilation. Native lookups can load code, which is not

  1041   // permitted during compilation.

  1042   //

  1043   // Note: A native method implies non-osr compilation which is

  1044   //       checked with an assertion at the entry of this method.

  1045   if (method->is_native()) {

  1046     bool in_base_library;

  1047     address adr = NativeLookup::lookup(method, in_base_library, THREAD);

  1048     if (HAS_PENDING_EXCEPTION) {

  1049       // In case of an exception looking up the method, we just forget

  1050       // about it. The interpreter will kick-in and throw the exception.

  1051       method->set_not_compilable(); // implies is_not_osr_compilable()

  1052       CLEAR_PENDING_EXCEPTION;

  1053       return NULL;

  1054     }

  1055     assert(method->has_native_function(), "must have native code by now");

  1056   }

  1058   // RedefineClasses() has replaced this method; just return

  1059   if (method->is_old()) {

  1060     return NULL;

  1061   }

  1063   // JVMTI -- post_compile_event requires jmethod_id() that may require

  1064   // a lock the compiling thread can not acquire. Prefetch it here.

  1065   if (JvmtiExport::should_post_compiled_method_load()) {

  1066     method->jmethod_id();

  1067   }

  1069   // If the compiler is shut off due to code cache flushing or otherwise,

  1070   // fail out now so blocking compiles dont hang the java thread

  1071   if (!should_compile_new_jobs() || (UseCodeCacheFlushing && CodeCache::needs_flushing())) {

  1072     CompilationPolicy::policy()->delay_compilation(method());

  1073     return NULL;

  1074   }

  1076   // do the compilation

  1077   if (method->is_native()) {

  1078     if (!PreferInterpreterNativeStubs) {

  1079       (void) AdapterHandlerLibrary::create_native_wrapper(method);

  1080     } else {

  1081       return NULL;

  1082     }

  1083   } else {

  1084     compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, CHECK_0);

  1085   }

  1087   // return requested nmethod

  1088   // We accept a higher level osr method

  1089   return osr_bci  == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci, comp_level, false);

  1090 }

  1093 // ------------------------------------------------------------------

  1094 // CompileBroker::compilation_is_complete

  1095 //

  1096 // See if compilation of this method is already complete.

  1097 bool CompileBroker::compilation_is_complete(methodHandle method,

  1098                                             int          osr_bci,

  1099                                             int          comp_level) {

  1100   bool is_osr = (osr_bci != standard_entry_bci);

  1101   if (is_osr) {

  1102     if (method->is_not_osr_compilable()) {

  1103       return true;

  1104     } else {

  1105       nmethod* result = method->lookup_osr_nmethod_for(osr_bci, comp_level, true);

  1106       return (result != NULL);

  1107     }

  1108   } else {

  1109     if (method->is_not_compilable(comp_level)) {

  1110       return true;

  1111     } else {

  1112       nmethod* result = method->code();

  1113       if (result == NULL) return false;

  1114       return comp_level == result->comp_level();

  1115     }

  1116   }

  1117 }

  1120 // ------------------------------------------------------------------

  1121 // CompileBroker::compilation_is_in_queue

  1122 //

  1123 // See if this compilation is already requested.

  1124 //

  1125 // Implementation note: there is only a single "is in queue" bit

  1126 // for each method.  This means that the check below is overly

  1127 // conservative in the sense that an osr compilation in the queue

  1128 // will block a normal compilation from entering the queue (and vice

  1129 // versa).  This can be remedied by a full queue search to disambiguate

  1130 // cases.  If it is deemed profitible, this may be done.

  1131 bool CompileBroker::compilation_is_in_queue(methodHandle method,

  1132                                             int          osr_bci) {

  1133   return method->queued_for_compilation();

  1134 }

  1136 // ------------------------------------------------------------------

  1137 // CompileBroker::compilation_is_prohibited

  1138 //

  1139 // See if this compilation is not allowed.

  1140 bool CompileBroker::compilation_is_prohibited(methodHandle method, int osr_bci, int comp_level) {

  1141   bool is_native = method->is_native();

  1142   // Some compilers may not support the compilation of natives.

  1143   if (is_native &&

  1144       (!CICompileNatives || !compiler(comp_level)->supports_native())) {

  1145     method->set_not_compilable_quietly(comp_level);

  1146     return true;

  1147   }

  1149   bool is_osr = (osr_bci != standard_entry_bci);

  1150   // Some compilers may not support on stack replacement.

  1151   if (is_osr &&

  1152       (!CICompileOSR || !compiler(comp_level)->supports_osr())) {

  1153     method->set_not_osr_compilable();

  1154     return true;

  1155   }

  1157   // The method may be explicitly excluded by the user.

  1158   bool quietly;

  1159   if (CompilerOracle::should_exclude(method, quietly)) {

  1160     if (!quietly) {

  1161       // This does not happen quietly...

  1162       ResourceMark rm;

  1163       tty->print("### Excluding %s:%s",

  1164                  method->is_native() ? "generation of native wrapper" : "compile",

  1165                  (method->is_static() ? " static" : ""));

  1166       method->print_short_name(tty);

  1167       tty->cr();

  1168     }

  1169     method->set_not_compilable_quietly();

  1170   }

  1172   return false;

  1173 }

  1176 // ------------------------------------------------------------------

  1177 // CompileBroker::assign_compile_id

  1178 //

  1179 // Assign a serialized id number to this compilation request.  If the

  1180 // number falls out of the allowed range, return a 0.  OSR

  1181 // compilations may be numbered separately from regular compilations

  1182 // if certain debugging flags are used.

  1183 uint CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {

  1184   assert(MethodCompileQueue_lock->owner() == Thread::current(),

  1185          "must hold the compilation queue lock");

  1186   bool is_osr = (osr_bci != standard_entry_bci);

  1187   assert(!method->is_native(), "no longer compile natives");

  1188   uint id;

  1189   if (CICountOSR && is_osr) {

  1190     id = ++_osr_compilation_id;

  1191     if ((uint)CIStartOSR <= id && id < (uint)CIStopOSR) {

  1192       return id;

  1193     }

  1194   } else {

  1195     id = ++_compilation_id;

  1196     if ((uint)CIStart <= id && id < (uint)CIStop) {

  1197       return id;

  1198     }

  1199   }

  1201   // Method was not in the appropriate compilation range.

  1202   method->set_not_compilable_quietly();

  1203   return 0;

  1204 }

  1207 // ------------------------------------------------------------------

  1208 // CompileBroker::is_compile_blocking

  1209 //

  1210 // Should the current thread be blocked until this compilation request

  1211 // has been fulfilled?

  1212 bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) {

  1213   return !BackgroundCompilation;

  1214 }

  1217 // ------------------------------------------------------------------

  1218 // CompileBroker::preload_classes

  1219 void CompileBroker::preload_classes(methodHandle method, TRAPS) {

  1220   // Move this code over from c1_Compiler.cpp

  1221   ShouldNotReachHere();

  1222 }

  1225 // ------------------------------------------------------------------

  1226 // CompileBroker::create_compile_task

  1227 //

  1228 // Create a CompileTask object representing the current request for

  1229 // compilation.  Add this task to the queue.

  1230 CompileTask* CompileBroker::create_compile_task(CompileQueue* queue,

  1231                                               int           compile_id,

  1232                                               methodHandle  method,

  1233                                               int           osr_bci,

  1234                                               int           comp_level,

  1235                                               methodHandle  hot_method,

  1236                                               int           hot_count,

  1237                                               const char*   comment,

  1238                                               bool          blocking) {

  1239   CompileTask* new_task = allocate_task();

  1240   new_task->initialize(compile_id, method, osr_bci, comp_level,

  1241                        hot_method, hot_count, comment,

  1242                        blocking);

  1243   queue->add(new_task);

  1244   return new_task;

  1245 }

  1248 // ------------------------------------------------------------------

  1249 // CompileBroker::allocate_task

  1250 //

  1251 // Allocate a CompileTask, from the free list if possible.

  1252 CompileTask* CompileBroker::allocate_task() {

  1253   MutexLocker locker(CompileTaskAlloc_lock);

  1254   CompileTask* task = NULL;

  1255   if (_task_free_list != NULL) {

  1256     task = _task_free_list;

  1257     _task_free_list = task->next();

  1258     task->set_next(NULL);

  1259   } else {

  1260     task = new CompileTask();

  1261     task->set_next(NULL);

  1262   }

  1263   return task;

  1264 }

  1267 // ------------------------------------------------------------------

  1268 // CompileBroker::free_task

  1269 //

  1270 // Add a task to the free list.

  1271 void CompileBroker::free_task(CompileTask* task) {

  1272   MutexLocker locker(CompileTaskAlloc_lock);

  1273   task->free();

  1274   task->set_next(_task_free_list);

  1275   _task_free_list = task;

  1276 }

  1279 // ------------------------------------------------------------------

  1280 // CompileBroker::wait_for_completion

  1281 //

  1282 // Wait for the given method CompileTask to complete.

  1283 void CompileBroker::wait_for_completion(CompileTask* task) {

  1284   if (CIPrintCompileQueue) {

  1285     tty->print_cr("BLOCKING FOR COMPILE");

  1286   }

  1288   assert(task->is_blocking(), "can only wait on blocking task");

  1290   JavaThread *thread = JavaThread::current();

  1291   thread->set_blocked_on_compilation(true);

  1293   methodHandle method(thread,

  1294                       (methodOop)JNIHandles::resolve(task->method_handle()));

  1295   {

  1296     MutexLocker waiter(task->lock(), thread);

  1298     while (!task->is_complete())

  1299       task->lock()->wait();

  1300   }

  1301   // It is harmless to check this status without the lock, because

  1302   // completion is a stable property (until the task object is recycled).

  1303   assert(task->is_complete(), "Compilation should have completed");

  1304   assert(task->code_handle() == NULL, "must be reset");

  1306   thread->set_blocked_on_compilation(false);

  1308   // By convention, the waiter is responsible for recycling a

  1309   // blocking CompileTask. Since there is only one waiter ever

  1310   // waiting on a CompileTask, we know that no one else will

  1311   // be using this CompileTask; we can free it.

  1312   free_task(task);

  1313 }

  1315 // ------------------------------------------------------------------

  1316 // CompileBroker::compiler_thread_loop

  1317 //

  1318 // The main loop run by a CompilerThread.

  1319 void CompileBroker::compiler_thread_loop() {

  1320   CompilerThread* thread = CompilerThread::current();

  1321   CompileQueue* queue = thread->queue();

  1323   // For the thread that initializes the ciObjectFactory

  1324   // this resource mark holds all the shared objects

  1325   ResourceMark rm;

  1327   // First thread to get here will initialize the compiler interface

  1329   if (!ciObjectFactory::is_initialized()) {

  1330     ASSERT_IN_VM;

  1331     MutexLocker only_one (CompileThread_lock, thread);

  1332     if (!ciObjectFactory::is_initialized()) {

  1333       ciObjectFactory::initialize();

  1334     }

  1335   }

  1337   // Open a log.

  1338   if (LogCompilation) {

  1339     init_compiler_thread_log();

  1340   }

  1341   CompileLog* log = thread->log();

  1342   if (log != NULL) {

  1343     log->begin_elem("start_compile_thread thread='" UINTX_FORMAT "' process='%d'",

  1344                     os::current_thread_id(),

  1345                     os::current_process_id());

  1346     log->stamp();

  1347     log->end_elem();

  1348   }

  1350   while (true) {

  1351     {

  1352       // We need this HandleMark to avoid leaking VM handles.

  1353       HandleMark hm(thread);

  1355       if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {

  1356         // the code cache is really full

  1357         handle_full_code_cache();

  1358       } else if (UseCodeCacheFlushing && CodeCache::needs_flushing()) {

  1359         // Attempt to start cleaning the code cache while there is still a little headroom

  1360         NMethodSweeper::handle_full_code_cache(false);

  1361       }

  1363       CompileTask* task = queue->get();

  1365       // Give compiler threads an extra quanta.  They tend to be bursty and

  1366       // this helps the compiler to finish up the job.

  1367       if( CompilerThreadHintNoPreempt )

  1368         os::hint_no_preempt();

  1370       // trace per thread time and compile statistics

  1371       CompilerCounters* counters = ((CompilerThread*)thread)->counters();

  1372       PerfTraceTimedEvent(counters->time_counter(), counters->compile_counter());

  1374       // Assign the task to the current thread.  Mark this compilation

  1375       // thread as active for the profiler.

  1376       CompileTaskWrapper ctw(task);

  1377       nmethodLocker result_handle;  // (handle for the nmethod produced by this task)

  1378       task->set_code_handle(&result_handle);

  1379       methodHandle method(thread,

  1380                      (methodOop)JNIHandles::resolve(task->method_handle()));

  1382       // Never compile a method if breakpoints are present in it

  1383       if (method()->number_of_breakpoints() == 0) {

  1384         // Compile the method.

  1385         if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {

  1386 #ifdef COMPILER1

  1387           // Allow repeating compilations for the purpose of benchmarking

  1388           // compile speed. This is not useful for customers.

  1389           if (CompilationRepeat != 0) {

  1390             int compile_count = CompilationRepeat;

  1391             while (compile_count > 0) {

  1392               invoke_compiler_on_method(task);

  1393               nmethod* nm = method->code();

  1394               if (nm != NULL) {

  1395                 nm->make_zombie();

  1396                 method->clear_code();

  1397               }

  1398               compile_count--;

  1399             }

  1400           }

  1401 #endif /* COMPILER1 */

  1402           invoke_compiler_on_method(task);

  1403         } else {

  1404           // After compilation is disabled, remove remaining methods from queue

  1405           method->clear_queued_for_compilation();

  1406         }

  1407       }

  1408     }

  1409   }

  1410 }

  1413 // ------------------------------------------------------------------

  1414 // CompileBroker::init_compiler_thread_log

  1415 //

  1416 // Set up state required by +LogCompilation.

  1417 void CompileBroker::init_compiler_thread_log() {

  1418     CompilerThread* thread = CompilerThread::current();

  1419     char  fileBuf[4*K];

  1420     FILE* fp = NULL;

  1421     char* file = NULL;

  1422     intx thread_id = os::current_thread_id();

  1423     for (int try_temp_dir = 1; try_temp_dir >= 0; try_temp_dir--) {

  1424       const char* dir = (try_temp_dir ? os::get_temp_directory() : NULL);

  1425       if (dir == NULL) {

  1426         jio_snprintf(fileBuf, sizeof(fileBuf), "hs_c" UINTX_FORMAT "_pid%u.log",

  1427                      thread_id, os::current_process_id());

  1428       } else {

  1429         jio_snprintf(fileBuf, sizeof(fileBuf),

  1430                      "%s%shs_c" UINTX_FORMAT "_pid%u.log", dir,

  1431                      os::file_separator(), thread_id, os::current_process_id());

  1432       }

  1433       fp = fopen(fileBuf, "at");

  1434       if (fp != NULL) {

  1435         file = NEW_C_HEAP_ARRAY(char, strlen(fileBuf)+1);

  1436         strcpy(file, fileBuf);

  1437         break;

  1438       }

  1439     }

  1440     if (fp == NULL) {

  1441       warning("Cannot open log file: %s", fileBuf);

  1442     } else {

  1443       if (LogCompilation && Verbose)

  1444         tty->print_cr("Opening compilation log %s", file);

  1445       CompileLog* log = new(ResourceObj::C_HEAP) CompileLog(file, fp, thread_id);

  1446       thread->init_log(log);

  1448       if (xtty != NULL) {

  1449         ttyLocker ttyl;

  1451         // Record any per thread log files

  1452         xtty->elem("thread_logfile thread='%d' filename='%s'", thread_id, file);

  1453       }

  1454     }

  1455 }

  1457 // ------------------------------------------------------------------

  1458 // CompileBroker::set_should_block

  1459 //

  1460 // Set _should_block.

  1461 // Call this from the VM, with Threads_lock held and a safepoint requested.

  1462 void CompileBroker::set_should_block() {

  1463   assert(Threads_lock->owner() == Thread::current(), "must have threads lock");

  1464   assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint already");

  1465 #ifndef PRODUCT

  1466   if (PrintCompilation && (Verbose || WizardMode))

  1467     tty->print_cr("notifying compiler thread pool to block");

  1468 #endif

  1469   _should_block = true;

  1470 }

  1472 // ------------------------------------------------------------------

  1473 // CompileBroker::maybe_block

  1474 //

  1475 // Call this from the compiler at convenient points, to poll for _should_block.

  1476 void CompileBroker::maybe_block() {

  1477   if (_should_block) {

  1478 #ifndef PRODUCT

  1479     if (PrintCompilation && (Verbose || WizardMode))

  1480       tty->print_cr("compiler thread " INTPTR_FORMAT " poll detects block request", Thread::current());

  1481 #endif

  1482     ThreadInVMfromNative tivfn(JavaThread::current());

  1483   }

  1484 }

  1487 // ------------------------------------------------------------------

  1488 // CompileBroker::invoke_compiler_on_method

  1489 //

  1490 // Compile a method.

  1491 //

  1492 void CompileBroker::invoke_compiler_on_method(CompileTask* task) {

  1493   if (PrintCompilation) {

  1494     ResourceMark rm;

  1495     task->print_line();

  1496   }

  1497   elapsedTimer time;

  1499   CompilerThread* thread = CompilerThread::current();

  1500   ResourceMark rm(thread);

  1502   // Common flags.

  1503   uint compile_id = task->compile_id();

  1504   int osr_bci = task->osr_bci();

  1505   bool is_osr = (osr_bci != standard_entry_bci);

  1506   bool should_log = (thread->log() != NULL);

  1507   bool should_break = false;

  1508   {

  1509     // create the handle inside it's own block so it can't

  1510     // accidentally be referenced once the thread transitions to

  1511     // native.  The NoHandleMark before the transition should catch

  1512     // any cases where this occurs in the future.

  1513     methodHandle method(thread,

  1514                         (methodOop)JNIHandles::resolve(task->method_handle()));

  1515     should_break = check_break_at(method, compile_id, is_osr);

  1516     if (should_log && !CompilerOracle::should_log(method)) {

  1517       should_log = false;

  1518     }

  1519     assert(!method->is_native(), "no longer compile natives");

  1521     // Save information about this method in case of failure.

  1522     set_last_compile(thread, method, is_osr, task->comp_level());

  1524     DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler(task->comp_level()), method);

  1525   }

  1527   // Allocate a new set of JNI handles.

  1528   push_jni_handle_block();

  1529   jobject target_handle = JNIHandles::make_local(thread, JNIHandles::resolve(task->method_handle()));

  1530   int compilable = ciEnv::MethodCompilable;

  1531   {

  1532     int system_dictionary_modification_counter;

  1533     {

  1534       MutexLocker locker(Compile_lock, thread);

  1535       system_dictionary_modification_counter = SystemDictionary::number_of_modifications();

  1536     }

  1538     NoHandleMark  nhm;

  1539     ThreadToNativeFromVM ttn(thread);

  1541     ciEnv ci_env(task, system_dictionary_modification_counter);

  1542     if (should_break) {

  1543       ci_env.set_break_at_compile(true);

  1544     }

  1545     if (should_log) {

  1546       ci_env.set_log(thread->log());

  1547     }

  1548     assert(thread->env() == &ci_env, "set by ci_env");

  1549     // The thread-env() field is cleared in ~CompileTaskWrapper.

  1551     // Cache Jvmti state

  1552     ci_env.cache_jvmti_state();

  1554     // Cache DTrace flags

  1555     ci_env.cache_dtrace_flags();

  1557     ciMethod* target = ci_env.get_method_from_handle(target_handle);

  1559     TraceTime t1("compilation", &time);

  1561     compiler(task->comp_level())->compile_method(&ci_env, target, osr_bci);

  1563     if (!ci_env.failing() && task->code() == NULL) {

  1564       //assert(false, "compiler should always document failure");

  1565       // The compiler elected, without comment, not to register a result.

  1566       // Do not attempt further compilations of this method.

  1567       ci_env.record_method_not_compilable("compile failed", !TieredCompilation);

  1568     }

  1570     if (ci_env.failing()) {

  1571       // Copy this bit to the enclosing block:

  1572       compilable = ci_env.compilable();

  1573       if (PrintCompilation) {

  1574         const char* reason = ci_env.failure_reason();

  1575         if (compilable == ciEnv::MethodCompilable_not_at_tier) {

  1576             tty->print_cr("%3d   COMPILE SKIPPED: %s (retry at different tier)", compile_id, reason);

  1577         } else if (compilable == ciEnv::MethodCompilable_never) {

  1578           tty->print_cr("%3d   COMPILE SKIPPED: %s (not retryable)", compile_id, reason);

  1579         } else if (compilable == ciEnv::MethodCompilable) {

  1580           tty->print_cr("%3d   COMPILE SKIPPED: %s", compile_id, reason);

  1581         }

  1582       }

  1583     } else {

  1584       task->mark_success();

  1585       task->set_num_inlined_bytecodes(ci_env.num_inlined_bytecodes());

  1586     }

  1587   }

  1588   pop_jni_handle_block();

  1590   methodHandle method(thread,

  1591                       (methodOop)JNIHandles::resolve(task->method_handle()));

  1593   DTRACE_METHOD_COMPILE_END_PROBE(compiler(task->comp_level()), method, task->is_success());

  1595   collect_statistics(thread, time, task);

  1597   if (compilable == ciEnv::MethodCompilable_never) {

  1598     if (is_osr) {

  1599       method->set_not_osr_compilable();

  1600     } else {

  1601       method->set_not_compilable_quietly();

  1602     }

  1603   } else if (compilable == ciEnv::MethodCompilable_not_at_tier) {

  1604     method->set_not_compilable_quietly(task->comp_level());

  1605   }

  1607   // Note that the queued_for_compilation bits are cleared without

  1608   // protection of a mutex. [They were set by the requester thread,

  1609   // when adding the task to the complie queue -- at which time the

  1610   // compile queue lock was held. Subsequently, we acquired the compile

  1611   // queue lock to get this task off the compile queue; thus (to belabour

  1612   // the point somewhat) our clearing of the bits must be occurring

  1613   // only after the setting of the bits. See also 14012000 above.

  1614   method->clear_queued_for_compilation();

  1616 #ifdef ASSERT

  1617   if (CollectedHeap::fired_fake_oom()) {

  1618     // The current compile received a fake OOM during compilation so

  1619     // go ahead and exit the VM since the test apparently succeeded

  1620     tty->print_cr("*** Shutting down VM after successful fake OOM");

  1621     vm_exit(0);

  1622   }

  1623 #endif

  1624 }

  1626 // ------------------------------------------------------------------

  1627 // CompileBroker::handle_full_code_cache

  1628 //

  1629 // The CodeCache is full.  Print out warning and disable compilation or

  1630 // try code cache cleaning so compilation can continue later.

  1631 void CompileBroker::handle_full_code_cache() {

  1632   UseInterpreter = true;

  1633   if (UseCompiler || AlwaysCompileLoopMethods ) {

  1634     if (xtty != NULL) {

  1635       xtty->begin_elem("code_cache_full");

  1636       xtty->stamp();

  1637       xtty->end_elem();

  1638     }

  1639     warning("CodeCache is full. Compiler has been disabled.");

  1640     warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");

  1641 #ifndef PRODUCT

  1642     if (CompileTheWorld || ExitOnFullCodeCache) {

  1643       before_exit(JavaThread::current());

  1644       exit_globals(); // will delete tty

  1645       vm_direct_exit(CompileTheWorld ? 0 : 1);

  1646     }

  1647 #endif

  1648     if (UseCodeCacheFlushing) {

  1649       NMethodSweeper::handle_full_code_cache(true);

  1650     } else {

  1651       UseCompiler               = false;

  1652       AlwaysCompileLoopMethods  = false;

  1653     }

  1654   }

  1655 }

  1657 // ------------------------------------------------------------------

  1658 // CompileBroker::set_last_compile

  1659 //

  1660 // Record this compilation for debugging purposes.

  1661 void CompileBroker::set_last_compile(CompilerThread* thread, methodHandle method, bool is_osr, int comp_level) {

  1662   ResourceMark rm;

  1663   char* method_name = method->name()->as_C_string();

  1664   strncpy(_last_method_compiled, method_name, CompileBroker::name_buffer_length);

  1665   char current_method[CompilerCounters::cmname_buffer_length];

  1666   size_t maxLen = CompilerCounters::cmname_buffer_length;

  1668   if (UsePerfData) {

  1669     const char* class_name = method->method_holder()->klass_part()->name()->as_C_string();

  1671     size_t s1len = strlen(class_name);

  1672     size_t s2len = strlen(method_name);

  1674     // check if we need to truncate the string

  1675     if (s1len + s2len + 2 > maxLen) {

  1677       // the strategy is to lop off the leading characters of the

  1678       // class name and the trailing characters of the method name.

  1680       if (s2len + 2 > maxLen) {

  1681         // lop of the entire class name string, let snprintf handle

  1682         // truncation of the method name.

  1683         class_name += s1len; // null string

  1684       }

  1685       else {

  1686         // lop off the extra characters from the front of the class name

  1687         class_name += ((s1len + s2len + 2) - maxLen);

  1688       }

  1689     }

  1691     jio_snprintf(current_method, maxLen, "%s %s", class_name, method_name);

  1692   }

  1694   if (CICountOSR && is_osr) {

  1695     _last_compile_type = osr_compile;

  1696   } else {

  1697     _last_compile_type = normal_compile;

  1698   }

  1699   _last_compile_level = comp_level;

  1701   if (UsePerfData) {

  1702     CompilerCounters* counters = thread->counters();

  1703     counters->set_current_method(current_method);

  1704     counters->set_compile_type((jlong)_last_compile_type);

  1705   }

  1706 }

  1709 // ------------------------------------------------------------------

  1710 // CompileBroker::push_jni_handle_block

  1711 //

  1712 // Push on a new block of JNI handles.

  1713 void CompileBroker::push_jni_handle_block() {

  1714   JavaThread* thread = JavaThread::current();

  1716   // Allocate a new block for JNI handles.

  1717   // Inlined code from jni_PushLocalFrame()

  1718   JNIHandleBlock* java_handles = thread->active_handles();

  1719   JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread);

  1720   assert(compile_handles != NULL && java_handles != NULL, "should not be NULL");

  1721   compile_handles->set_pop_frame_link(java_handles);  // make sure java handles get gc'd.

  1722   thread->set_active_handles(compile_handles);

  1723 }

  1726 // ------------------------------------------------------------------

  1727 // CompileBroker::pop_jni_handle_block

  1728 //

  1729 // Pop off the current block of JNI handles.

  1730 void CompileBroker::pop_jni_handle_block() {

  1731   JavaThread* thread = JavaThread::current();

  1733   // Release our JNI handle block

  1734   JNIHandleBlock* compile_handles = thread->active_handles();

  1735   JNIHandleBlock* java_handles = compile_handles->pop_frame_link();

  1736   thread->set_active_handles(java_handles);

  1737   compile_handles->set_pop_frame_link(NULL);

  1738   JNIHandleBlock::release_block(compile_handles, thread); // may block

  1739 }

  1742 // ------------------------------------------------------------------

  1743 // CompileBroker::check_break_at

  1744 //

  1745 // Should the compilation break at the current compilation.

  1746 bool CompileBroker::check_break_at(methodHandle method, int compile_id, bool is_osr) {

  1747   if (CICountOSR && is_osr && (compile_id == CIBreakAtOSR)) {

  1748     return true;

  1749   } else if( CompilerOracle::should_break_at(method) ) { // break when compiling

  1750     return true;

  1751   } else {

  1752     return (compile_id == CIBreakAt);

  1753   }

  1754 }

  1756 // ------------------------------------------------------------------

  1757 // CompileBroker::collect_statistics

  1758 //

  1759 // Collect statistics about the compilation.

  1761 void CompileBroker::collect_statistics(CompilerThread* thread, elapsedTimer time, CompileTask* task) {

  1762   bool success = task->is_success();

  1763   methodHandle method (thread, (methodOop)JNIHandles::resolve(task->method_handle()));

  1764   uint compile_id = task->compile_id();

  1765   bool is_osr = (task->osr_bci() != standard_entry_bci);

  1766   nmethod* code = task->code();

  1767   CompilerCounters* counters = thread->counters();

  1769   assert(code == NULL || code->is_locked_by_vm(), "will survive the MutexLocker");

  1770   MutexLocker locker(CompileStatistics_lock);

  1772   // _perf variables are production performance counters which are

  1773   // updated regardless of the setting of the CITime and CITimeEach flags

  1774   //

  1775   if (!success) {

  1776     _total_bailout_count++;

  1777     if (UsePerfData) {

  1778       _perf_last_failed_method->set_value(counters->current_method());

  1779       _perf_last_failed_type->set_value(counters->compile_type());

  1780       _perf_total_bailout_count->inc();

  1781     }

  1782   } else if (code == NULL) {

  1783     if (UsePerfData) {

  1784       _perf_last_invalidated_method->set_value(counters->current_method());

  1785       _perf_last_invalidated_type->set_value(counters->compile_type());

  1786       _perf_total_invalidated_count->inc();

  1787     }

  1788     _total_invalidated_count++;

  1789   } else {

  1790     // Compilation succeeded

  1792     // update compilation ticks - used by the implementation of

  1793     // java.lang.management.CompilationMBean

  1794     _perf_total_compilation->inc(time.ticks());

  1796     if (CITime) {

  1797       _t_total_compilation.add(time);

  1798       if (is_osr) {

  1799         _t_osr_compilation.add(time);

  1800         _sum_osr_bytes_compiled += method->code_size() + task->num_inlined_bytecodes();

  1801       } else {

  1802         _t_standard_compilation.add(time);

  1803         _sum_standard_bytes_compiled += method->code_size() + task->num_inlined_bytecodes();

  1804       }

  1805     }

  1807     if (UsePerfData) {

  1808       // save the name of the last method compiled

  1809       _perf_last_method->set_value(counters->current_method());

  1810       _perf_last_compile_type->set_value(counters->compile_type());

  1811       _perf_last_compile_size->set_value(method->code_size() +

  1812                                          task->num_inlined_bytecodes());

  1813       if (is_osr) {

  1814         _perf_osr_compilation->inc(time.ticks());

  1815         _perf_sum_osr_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());

  1816       } else {

  1817         _perf_standard_compilation->inc(time.ticks());

  1818         _perf_sum_standard_bytes_compiled->inc(method->code_size() + task->num_inlined_bytecodes());

  1819       }

  1820     }

  1822     if (CITimeEach) {

  1823       float bytes_per_sec = 1.0 * (method->code_size() + task->num_inlined_bytecodes()) / time.seconds();

  1824       tty->print_cr("%3d   seconds: %f bytes/sec : %f (bytes %d + %d inlined)",

  1825                     compile_id, time.seconds(), bytes_per_sec, method->code_size(), task->num_inlined_bytecodes());

  1826     }

  1828     // Collect counts of successful compilations

  1829     _sum_nmethod_size      += code->total_size();

  1830     _sum_nmethod_code_size += code->insts_size();

  1831     _total_compile_count++;

  1833     if (UsePerfData) {

  1834       _perf_sum_nmethod_size->inc(     code->total_size());

  1835       _perf_sum_nmethod_code_size->inc(code->insts_size());

  1836       _perf_total_compile_count->inc();

  1837     }

  1839     if (is_osr) {

  1840       if (UsePerfData) _perf_total_osr_compile_count->inc();

  1841       _total_osr_compile_count++;

  1842     } else {

  1843       if (UsePerfData) _perf_total_standard_compile_count->inc();

  1844       _total_standard_compile_count++;

  1845     }

  1846   }

  1847   // set the current method for the thread to null

  1848   if (UsePerfData) counters->set_current_method("");

  1849 }

  1853 void CompileBroker::print_times() {

  1854   tty->cr();

  1855   tty->print_cr("Accumulated compiler times (for compiled methods only)");

  1856   tty->print_cr("------------------------------------------------");

  1857                //0000000000111111111122222222223333333333444444444455555555556666666666

  1858                //0123456789012345678901234567890123456789012345678901234567890123456789

  1859   tty->print_cr("  Total compilation time   : %6.3f s", CompileBroker::_t_total_compilation.seconds());

  1860   tty->print_cr("    Standard compilation   : %6.3f s, Average : %2.3f",

  1861                 CompileBroker::_t_standard_compilation.seconds(),

  1862                 CompileBroker::_t_standard_compilation.seconds() / CompileBroker::_total_standard_compile_count);

  1863   tty->print_cr("    On stack replacement   : %6.3f s, Average : %2.3f", CompileBroker::_t_osr_compilation.seconds(), CompileBroker::_t_osr_compilation.seconds() / CompileBroker::_total_osr_compile_count);

  1865   if (compiler(CompLevel_simple) != NULL) {

  1866     compiler(CompLevel_simple)->print_timers();

  1867   }

  1868   if (compiler(CompLevel_full_optimization) != NULL) {

  1869     compiler(CompLevel_full_optimization)->print_timers();

  1870   }

  1871   tty->cr();

  1872   int tcb = CompileBroker::_sum_osr_bytes_compiled + CompileBroker::_sum_standard_bytes_compiled;

  1873   tty->print_cr("  Total compiled bytecodes : %6d bytes", tcb);

  1874   tty->print_cr("    Standard compilation   : %6d bytes", CompileBroker::_sum_standard_bytes_compiled);

  1875   tty->print_cr("    On stack replacement   : %6d bytes", CompileBroker::_sum_osr_bytes_compiled);

  1876   int bps = (int)(tcb / CompileBroker::_t_total_compilation.seconds());

  1877   tty->print_cr("  Average compilation speed: %6d bytes/s", bps);

  1878   tty->cr();

  1879   tty->print_cr("  nmethod code size        : %6d bytes", CompileBroker::_sum_nmethod_code_size);

  1880   tty->print_cr("  nmethod total size       : %6d bytes", CompileBroker::_sum_nmethod_size);

  1881 }

  1884 // Debugging output for failure

  1885 void CompileBroker::print_last_compile() {

  1886   if ( _last_compile_level != CompLevel_none &&

  1887        compiler(_last_compile_level) != NULL &&

  1888        _last_method_compiled != NULL &&

  1889        _last_compile_type != no_compile) {

  1890     if (_last_compile_type == osr_compile) {

  1891       tty->print_cr("Last parse:  [osr]%d+++(%d) %s",

  1892                     _osr_compilation_id, _last_compile_level, _last_method_compiled);

  1893     } else {

  1894       tty->print_cr("Last parse:  %d+++(%d) %s",

  1895                     _compilation_id, _last_compile_level, _last_method_compiled);

  1896     }

  1897   }

  1898 }

  1901 void CompileBroker::print_compiler_threads_on(outputStream* st) {

  1902 #ifndef PRODUCT

  1903   st->print_cr("Compiler thread printing unimplemented.");

  1904   st->cr();

  1905 #endif

  1906 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/compiler/compileBroker.cpp@2f644f85485d

src/share/vm/compiler/compileBroker.cpp