jdk8-mips64-public/hotspot: src/share/vm/compiler/compileBroker.cpp@3e8fbc61cee8

6978355: renaming for 6961697
Summary: This is the renaming part of 6961697 to keep the actual changes small for review.
Reviewed-by: kvn, never

     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 "incls/_precompiled.incl"

    26 #include "incls/_compileBroker.cpp.incl"

    28 #ifdef DTRACE_ENABLED

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

    32 HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin,

    33   char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t);

    34 HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end,

    35   char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t, bool);

    37 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)              \

    38   {                                                                      \

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

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

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

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

    43     HS_DTRACE_PROBE8(hotspot, method__compile__begin,                    \

    44       comp_name, strlen(comp_name),                                      \

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

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

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

    48   }

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

    51   {                                                                      \

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

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

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

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

    56     HS_DTRACE_PROBE9(hotspot, method__compile__end,                      \

    57       comp_name, strlen(comp_name),                                      \

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

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

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

    61   }

    63 #else //  ndef DTRACE_ENABLED

    65 #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)

    66 #define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)

    68 #endif // ndef DTRACE_ENABLED

    70 bool CompileBroker::_initialized = false;

    71 volatile bool CompileBroker::_should_block = false;

    72 volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;

    74 // The installed compiler(s)

    75 AbstractCompiler* CompileBroker::_compilers[2];

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

    78 uint CompileBroker::_compilation_id        = 0;

    79 uint CompileBroker::_osr_compilation_id    = 0;

    81 // Debugging information

    82 int  CompileBroker::_last_compile_type     = no_compile;

    83 int  CompileBroker::_last_compile_level    = CompLevel_none;

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

    86 // Performance counters

    87 PerfCounter* CompileBroker::_perf_total_compilation = NULL;

    88 PerfCounter* CompileBroker::_perf_osr_compilation = NULL;

    89 PerfCounter* CompileBroker::_perf_standard_compilation = NULL;

    91 PerfCounter* CompileBroker::_perf_total_bailout_count = NULL;

    92 PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL;

    93 PerfCounter* CompileBroker::_perf_total_compile_count = NULL;

    94 PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL;

    95 PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL;

    97 PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL;

    98 PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL;

    99 PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL;

   100 PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL;

   102 PerfStringVariable* CompileBroker::_perf_last_method = NULL;

   103 PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL;

   104 PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL;

   105 PerfVariable*       CompileBroker::_perf_last_compile_type = NULL;

   106 PerfVariable*       CompileBroker::_perf_last_compile_size = NULL;

   107 PerfVariable*       CompileBroker::_perf_last_failed_type = NULL;

   108 PerfVariable*       CompileBroker::_perf_last_invalidated_type = NULL;

   110 // Timers and counters for generating statistics

   111 elapsedTimer CompileBroker::_t_total_compilation;

   112 elapsedTimer CompileBroker::_t_osr_compilation;

   113 elapsedTimer CompileBroker::_t_standard_compilation;

   115 int CompileBroker::_total_bailout_count          = 0;

   116 int CompileBroker::_total_invalidated_count      = 0;

   117 int CompileBroker::_total_compile_count          = 0;

   118 int CompileBroker::_total_osr_compile_count      = 0;

   119 int CompileBroker::_total_standard_compile_count = 0;

   121 int CompileBroker::_sum_osr_bytes_compiled       = 0;

   122 int CompileBroker::_sum_standard_bytes_compiled  = 0;

   123 int CompileBroker::_sum_nmethod_size             = 0;

   124 int CompileBroker::_sum_nmethod_code_size        = 0;

   126 CompileQueue* CompileBroker::_method_queue   = NULL;

   127 CompileTask*  CompileBroker::_task_free_list = NULL;

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

   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 };

   141 CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {

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

   143   thread->set_task(task);

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

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

   146 }

   148 CompileTaskWrapper::~CompileTaskWrapper() {

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

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

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

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

   153   thread->set_task(NULL);

   154   task->set_code_handle(NULL);

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

   156   if (task->is_blocking()) {

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

   158     task->mark_complete();

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

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

   161   } else {

   162     task->mark_complete();

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

   165     // recycling a non-blocking CompileTask.

   166     CompileBroker::free_task(task);

   167   }

   168 }

   171 // ------------------------------------------------------------------

   172 // CompileTask::initialize

   173 void CompileTask::initialize(int compile_id,

   174                              methodHandle method,

   175                              int osr_bci,

   176                              int comp_level,

   177                              methodHandle hot_method,

   178                              int hot_count,

   179                              const char* comment,

   180                              bool is_blocking) {

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

   183   _compile_id = compile_id;

   184   _method = JNIHandles::make_global(method);

   185   _osr_bci = osr_bci;

   186   _is_blocking = is_blocking;

   187   _comp_level = comp_level;

   188   _num_inlined_bytecodes = 0;

   190   _is_complete = false;

   191   _is_success = false;

   192   _code_handle = NULL;

   194   _hot_method = NULL;

   195   _hot_count = hot_count;

   196   _time_queued = 0;  // tidy

   197   _comment = comment;

   199   if (LogCompilation) {

   200     _time_queued = os::elapsed_counter();

   201     if (hot_method.not_null()) {

   202       if (hot_method == method) {

   203         _hot_method = _method;

   204       } else {

   205         _hot_method = JNIHandles::make_global(hot_method);

   206       }

   207     }

   208   }

   210   _next = NULL;

   211 }

   213 // ------------------------------------------------------------------

   214 // CompileTask::code/set_code

   215 nmethod* CompileTask::code() const {

   216   if (_code_handle == NULL)  return NULL;

   217   return _code_handle->code();

   218 }

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

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

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

   222   _code_handle->set_code(nm);

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

   224 }

   226 // ------------------------------------------------------------------

   227 // CompileTask::free

   228 void CompileTask::free() {

   229   set_code(NULL);

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

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

   232     JNIHandles::destroy_global(_hot_method);

   233   }

   234   JNIHandles::destroy_global(_method);

   235 }

   238 // ------------------------------------------------------------------

   239 // CompileTask::print

   240 void CompileTask::print() {

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

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

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

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

   245              _osr_bci, bool_to_str(_is_blocking),

   246              bool_to_str(_is_complete), bool_to_str(_is_success));

   247 }

   249 // ------------------------------------------------------------------

   250 // CompileTask::print_line_on_error

   251 //

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

   253 // causing troubles is a compiler thread.

   254 //

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

   256 //

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

   258 //

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

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

   262   // print compiler name

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

   265   // print compilation number

   266   st->print("%3d", compile_id());

   268   // print method attributes

   269   const bool is_osr = osr_bci() != CompileBroker::standard_entry_bci;

   270   { const char blocking_char  = is_blocking()                      ? 'b' : ' ';

   271     const char compile_type   = is_osr                             ? '%' : ' ';

   272     const char sync_char      = method->is_synchronized()          ? 's' : ' ';

   273     const char exception_char = method->has_exception_handler()    ? '!' : ' ';

   274     const char tier_char      =

   275       is_highest_tier_compile(comp_level())                        ? ' ' : ('0' + comp_level());

   276     st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, tier_char);

   277   }

   279   // Use buf to get method name and signature

   280   if (method != NULL) st->print("%s", method->name_and_sig_as_C_string(buf, buflen));

   282   // print osr_bci if any

   283   if (is_osr) st->print(" @ %d", osr_bci());

   285   // print method size

   286   st->print_cr(" (%d bytes)", method->code_size());

   287 }

   289 // ------------------------------------------------------------------

   290 // CompileTask::print_line

   291 void CompileTask::print_line() {

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

   293   methodHandle method(thread,

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

   295   ResourceMark rm(thread);

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

   299   // print compiler name if requested

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

   302   // print compilation number

   303   tty->print("%3d", compile_id());

   305   // print method attributes

   306   const bool is_osr = osr_bci() != CompileBroker::standard_entry_bci;

   307   { const char blocking_char  = is_blocking()                      ? 'b' : ' ';

   308     const char compile_type   = is_osr                             ? '%' : ' ';

   309     const char sync_char      = method->is_synchronized()          ? 's' : ' ';

   310     const char exception_char = method->has_exception_handler()    ? '!' : ' ';

   311     const char tier_char      =

   312       is_highest_tier_compile(comp_level())                        ? ' ' : ('0' + comp_level());

   313     tty->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, tier_char);

   314   }

   316   // print method name

   317   method->print_short_name(tty);

   319   // print osr_bci if any

   320   if (is_osr) tty->print(" @ %d", osr_bci());

   322   // print method size

   323   tty->print_cr(" (%d bytes)", method->code_size());

   324 }

   327 // ------------------------------------------------------------------

   328 // CompileTask::log_task

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

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

   331   methodHandle method(thread,

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

   333   ResourceMark rm(thread);

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

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

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

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

   339   } // else compile_kind='c2c'

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

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

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

   343   }

   344   if (_comp_level != CompLevel_highest_tier) {

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

   346   }

   347   if (_is_blocking) {

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

   349   }

   350   log->stamp();

   351 }

   354 // ------------------------------------------------------------------

   355 // CompileTask::log_task_queued

   356 void CompileTask::log_task_queued() {

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

   358   ttyLocker ttyl;

   359   ResourceMark rm(thread);

   361   xtty->begin_elem("task_queued");

   362   log_task(xtty);

   363   if (_comment != NULL) {

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

   365   }

   366   if (_hot_method != NULL) {

   367     methodHandle hot(thread,

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

   369     methodHandle method(thread,

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

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

   372       xtty->method(hot);

   373     }

   374   }

   375   if (_hot_count != 0) {

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

   377   }

   378   xtty->end_elem();

   379 }

   382 // ------------------------------------------------------------------

   383 // CompileTask::log_task_start

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

   385   log->begin_head("task");

   386   log_task(log);

   387   log->end_head();

   388 }

   391 // ------------------------------------------------------------------

   392 // CompileTask::log_task_done

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

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

   395   methodHandle method(thread,

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

   397   ResourceMark rm(thread);

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

   400   nmethod* nm = code();

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

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

   403                   method->invocation_count());

   404   int bec = method->backedge_count();

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

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

   407   if (_num_inlined_bytecodes != 0) {

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

   409   }

   410   log->stamp();

   411   log->end_elem();

   412   log->tail("task");

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

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

   415     log->flush();

   416   }

   417   log->mark_file_end();

   418 }

   422 // ------------------------------------------------------------------

   423 // CompileQueue::add

   424 //

   425 // Add a CompileTask to a CompileQueue

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

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

   429   task->set_next(NULL);

   431   if (_last == NULL) {

   432     // The compile queue is empty.

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

   434     _first = task;

   435     _last = task;

   436   } else {

   437     // Append the task to the queue.

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

   439     _last->set_next(task);

   440     _last = task;

   441   }

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

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

   446   if (CIPrintCompileQueue) {

   447     print();

   448   }

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

   451     task->log_task_queued();

   452   }

   454   // Notify CompilerThreads that a task is available.

   455   lock()->notify();

   456 }

   459 // ------------------------------------------------------------------

   460 // CompileQueue::get

   461 //

   462 // Get the next CompileTask from a CompileQueue

   463 CompileTask* CompileQueue::get() {

   464   NMethodSweeper::possibly_sweep();

   466   MutexLocker locker(lock());

   468   // Wait for an available CompileTask.

   469   while (_first == NULL) {

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

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

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

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

   474       if (timedout) {

   475         MutexUnlocker ul(lock());

   476         // When otherwise not busy, run nmethod sweeping

   477         NMethodSweeper::possibly_sweep();

   478       }

   479     } else {

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

   481       lock()->wait();

   482     }

   483   }

   485   CompileTask* task = _first;

   487   // Update queue first and last

   488   _first =_first->next();

   489   if (_first == NULL) {

   490     _last = NULL;

   491   }

   493   return task;

   495 }

   498 // ------------------------------------------------------------------

   499 // CompileQueue::print

   500 void CompileQueue::print() {

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

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

   503   CompileTask* task = _first;

   504   while (task != NULL) {

   505     task->print_line();

   506     task = task->next();

   507   }

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

   509 }

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

   513   _current_method[0] = '\0';

   514   _compile_type = CompileBroker::no_compile;

   516   if (UsePerfData) {

   517     ResourceMark rm;

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

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

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

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

   523                       PerfDataManager::name_space(thread_name, instance);

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

   527     _perf_current_method =

   528                PerfDataManager::create_string_variable(SUN_CI, name,

   529                                                        cmname_buffer_length,

   530                                                        _current_method, CHECK);

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

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

   534                                                           PerfData::U_None,

   535                                                          (jlong)_compile_type,

   536                                                           CHECK);

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

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

   540                                                  PerfData::U_Ticks, CHECK);

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

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

   544                                                      PerfData::U_Events, CHECK);

   545   }

   546 }

   549 // ------------------------------------------------------------------

   550 // CompileBroker::compilation_init

   551 //

   552 // Initialize the Compilation object

   553 void CompileBroker::compilation_init() {

   554   _last_method_compiled[0] = '\0';

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

   557 #ifdef COMPILER1

   558   _compilers[0] = new Compiler();

   559 #ifndef COMPILER2

   560   _compilers[1] = _compilers[0];

   561 #endif

   562 #endif // COMPILER1

   564 #ifdef COMPILER2

   565   _compilers[1] = new C2Compiler();

   566 #ifndef COMPILER1

   567   _compilers[0] = _compilers[1];

   568 #endif

   569 #endif // COMPILER2

   571 #ifdef SHARK

   572 #if defined(COMPILER1) || defined(COMPILER2)

   573 #error "Can't use COMPILER1 or COMPILER2 with shark"

   574 #endif

   575   _compilers[0] = new SharkCompiler();

   576   _compilers[1] = _compilers[0];

   577 #endif

   579   // Initialize the CompileTask free list

   580   _task_free_list = NULL;

   582   // Start the CompilerThreads

   583   init_compiler_threads(compiler_count());

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

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

   588   {

   589     EXCEPTION_MARK;

   590     _perf_total_compilation =

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

   592                                                  PerfData::U_Ticks, CHECK);

   593   }

   596   if (UsePerfData) {

   598     EXCEPTION_MARK;

   600     // create the jvmstat performance counters

   601     _perf_osr_compilation =

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

   603                                                  PerfData::U_Ticks, CHECK);

   605     _perf_standard_compilation =

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

   607                                                  PerfData::U_Ticks, CHECK);

   609     _perf_total_bailout_count =

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

   611                                                  PerfData::U_Events, CHECK);

   613     _perf_total_invalidated_count =

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

   615                                                  PerfData::U_Events, CHECK);

   617     _perf_total_compile_count =

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

   619                                                  PerfData::U_Events, CHECK);

   620     _perf_total_osr_compile_count =

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

   622                                                  PerfData::U_Events, CHECK);

   624     _perf_total_standard_compile_count =

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

   626                                                  PerfData::U_Events, CHECK);

   628     _perf_sum_osr_bytes_compiled =

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

   630                                                  PerfData::U_Bytes, CHECK);

   632     _perf_sum_standard_bytes_compiled =

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

   634                                                  PerfData::U_Bytes, CHECK);

   636     _perf_sum_nmethod_size =

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

   638                                                  PerfData::U_Bytes, CHECK);

   640     _perf_sum_nmethod_code_size =

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

   642                                                  PerfData::U_Bytes, CHECK);

   644     _perf_last_method =

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

   646                                        CompilerCounters::cmname_buffer_length,

   647                                        "", CHECK);

   649     _perf_last_failed_method =

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

   651                                        CompilerCounters::cmname_buffer_length,

   652                                        "", CHECK);

   654     _perf_last_invalidated_method =

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

   656                                      CompilerCounters::cmname_buffer_length,

   657                                      "", CHECK);

   659     _perf_last_compile_type =

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

   661                                               PerfData::U_None,

   662                                               (jlong)CompileBroker::no_compile,

   663                                               CHECK);

   665     _perf_last_compile_size =

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

   667                                               PerfData::U_Bytes,

   668                                               (jlong)CompileBroker::no_compile,

   669                                               CHECK);

   672     _perf_last_failed_type =

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

   674                                               PerfData::U_None,

   675                                               (jlong)CompileBroker::no_compile,

   676                                               CHECK);

   678     _perf_last_invalidated_type =

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

   680                                           PerfData::U_None,

   681                                           (jlong)CompileBroker::no_compile,

   682                                           CHECK);

   683   }

   685   _initialized = true;

   686 }

   690 // ------------------------------------------------------------------

   691 // CompileBroker::make_compiler_thread

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

   693   CompilerThread* compiler_thread = NULL;

   695   klassOop k =

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

   697                                       true, CHECK_0);

   698   instanceKlassHandle klass (THREAD, k);

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

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

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

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

   704   JavaValue result(T_VOID);

   705   JavaCalls::call_special(&result, thread_oop,

   706                        klass,

   707                        vmSymbolHandles::object_initializer_name(),

   708                        vmSymbolHandles::threadgroup_string_void_signature(),

   709                        thread_group,

   710                        string,

   711                        CHECK_0);

   713   {

   714     MutexLocker mu(Threads_lock, THREAD);

   715     compiler_thread = new CompilerThread(queue, counters);

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

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

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

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

   720     // newly created CompilerThread runs at.

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

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

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

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

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

   729       vm_exit_during_initialization("java.lang.OutOfMemoryError",

   730                                     "unable to create new native thread");

   731     }

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

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

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

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

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

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

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

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

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

   743     // comment) and unconditionally set the priority.

   745     // Compiler Threads should be at the highest Priority

   746     if ( CompilerThreadPriority != -1 )

   747       os::set_native_priority( compiler_thread, CompilerThreadPriority );

   748     else

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

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

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

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

   754       // thread.

   756     java_lang_Thread::set_daemon(thread_oop());

   758     compiler_thread->set_threadObj(thread_oop());

   759     Threads::add(compiler_thread);

   760     Thread::start(compiler_thread);

   761   }

   762   // Let go of Threads_lock before yielding

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

   765   return compiler_thread;

   766 }

   769 // ------------------------------------------------------------------

   770 // CompileBroker::init_compiler_threads

   771 //

   772 // Initialize the compilation queue

   773 void CompileBroker::init_compiler_threads(int compiler_count) {

   774   EXCEPTION_MARK;

   776   _method_queue  = new CompileQueue("MethodQueue",  MethodCompileQueue_lock);

   777   _method_threads =

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

   780   char name_buffer[256];

   781   int i;

   782   for (i = 0; i < compiler_count; i++) {

   783     // Create a name for our thread.

   784     sprintf(name_buffer, "CompilerThread%d", i);

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

   787     CompilerThread* new_thread = make_compiler_thread(name_buffer, _method_queue, counters, CHECK);

   788     _method_threads->append(new_thread);

   789   }

   790   if (UsePerfData) {

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

   792                                      compiler_count, CHECK);

   793   }

   794 }

   796 // ------------------------------------------------------------------

   797 // CompileBroker::is_idle

   798 bool CompileBroker::is_idle() {

   799   if (!_method_queue->is_empty()) {

   800     return false;

   801   } else {

   802     int num_threads = _method_threads->length();

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

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

   805         return false;

   806       }

   807     }

   809     // No pending or active compilations.

   810     return true;

   811   }

   812 }

   815 // ------------------------------------------------------------------

   816 // CompileBroker::compile_method

   817 //

   818 // Request compilation of a method.

   819 void CompileBroker::compile_method_base(methodHandle method,

   820                                         int osr_bci,

   821                                         int comp_level,

   822                                         methodHandle hot_method,

   823                                         int hot_count,

   824                                         const char* comment,

   825                                         TRAPS) {

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

   827   if (!_initialized ) {

   828     return;

   829   }

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

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

   833          "sanity check");

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

   835          "method holder must be initialized");

   837   if (CIPrintRequests) {

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

   839     method->print_short_name(tty);

   840     if (osr_bci != InvocationEntryBci) {

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

   842     }

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

   844     if (!hot_method.is_null()) {

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

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

   847           hot_method->print_short_name(tty);

   848       } else {

   849         tty->print("yes");

   850       }

   851     }

   852     tty->cr();

   853   }

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

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

   857   // in the meantime with a definitive result.

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

   859     return;

   860   }

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

   863   // we do not block the current thread.

   864   if (compilation_is_in_queue(method, osr_bci)) {

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

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

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

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

   869     // all subsequent blocking requesters wait for completion of

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

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

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

   873     return;

   874   }

   876   // Outputs from the following MutexLocker block:

   877   CompileTask* task     = NULL;

   878   bool         blocking = false;

   880   // Acquire our lock.

   881   {

   882     MutexLocker locker(_method_queue->lock(), THREAD);

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

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

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

   887     if (compilation_is_in_queue(method, osr_bci)) {

   888       return;

   889     }

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

   892     // completed.  A previous compilation may have registered

   893     // some result.

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

   895       return;

   896     }

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

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

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

   901     uint compile_id = assign_compile_id(method, osr_bci);

   902     if (compile_id == 0) {

   903       // The compilation falls outside the allowed range.

   904       return;

   905     }

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

   908     blocking = is_compile_blocking(method, osr_bci);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   925     // the compilation result and then clears the queued_for_compile

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

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

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

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

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

   931     // <RESULT, QUEUE> :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   947     // common lock.

   948     task = create_compile_task(_method_queue,

   949                                compile_id, method,

   950                                osr_bci, comp_level,

   951                                hot_method, hot_count, comment,

   952                                blocking);

   953   }

   955   if (blocking) {

   956     wait_for_completion(task);

   957   }

   958 }

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

   962                                        methodHandle hot_method, int hot_count,

   963                                        const char* comment, TRAPS) {

   964   // make sure arguments make sense

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

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

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

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

   970   int comp_level = CompilationPolicy::policy()->compilation_level(method, osr_bci);

   972 #ifdef TIERED

   973   if (TieredCompilation && StressTieredRuntime) {

   974     static int flipper = 0;

   975     if (is_even(flipper++)) {

   976       comp_level = CompLevel_fast_compile;

   977     } else {

   978       comp_level = CompLevel_full_optimization;

   979     }

   980   }

   981 #ifdef SPARC

   982   // QQQ FIX ME

   983   // C2 only returns long results in G1 and c1 doesn't understand so disallow c2

   984   // compiles of long results

   985   if (TieredCompilation && method()->result_type() == T_LONG) {

   986     comp_level = CompLevel_fast_compile;

   987   }

   988 #endif // SPARC

   989 #endif // TIERED

   991   // return quickly if possible

   993   // lock, make sure that the compilation

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

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

   997     return NULL;

   998   }

  1000   if (osr_bci == InvocationEntryBci) {

  1001     // standard compilation

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

  1003     if (method_code != NULL

  1004 #ifdef TIERED

  1005        && ( method_code->is_compiled_by_c2() || comp_level == CompLevel_fast_compile )

  1006 #endif // TIERED

  1007       ) {

  1008       return method_code;

  1009     }

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

  1012     if (UseCodeCacheFlushing) {

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

  1014       if (saved != NULL) {

  1015         method->set_code(method, saved);

  1016         return saved;

  1017       }

  1018     }

  1020   } else {

  1021     // osr compilation

  1022 #ifndef TIERED

  1023     // seems like an assert of dubious value

  1024     assert(comp_level == CompLevel_full_optimization,

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

  1026 #endif // TIERED

  1027     nmethod* nm = method->lookup_osr_nmethod_for(osr_bci);

  1028     if (nm != NULL) return nm;

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

  1030   }

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

  1033   // some prerequisites that are compiler specific

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

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

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

  1037     // we are compiling.

  1038     methodOopDesc::load_signature_classes(method, CHECK_0);

  1039   }

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

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

  1043   // permitted during compilation.

  1044   //

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

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

  1047   if (method->is_native()) {

  1048     bool in_base_library;

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

  1050     if (HAS_PENDING_EXCEPTION) {

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

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

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

  1054       CLEAR_PENDING_EXCEPTION;

  1055       return NULL;

  1056     }

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

  1058   }

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

  1061   if (method->is_old()) {

  1062     return NULL;

  1063   }

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

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

  1067   if (JvmtiExport::should_post_compiled_method_load()) {

  1068     method->jmethod_id();

  1069   }

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

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

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

  1074     method->invocation_counter()->decay();

  1075     method->backedge_counter()->decay();

  1076     return NULL;

  1077   }

  1079   // do the compilation

  1080   if (method->is_native()) {

  1081     if (!PreferInterpreterNativeStubs) {

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

  1083     } else {

  1084       return NULL;

  1085     }

  1086   } else {

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

  1088   }

  1090   // return requested nmethod

  1091   return osr_bci  == InvocationEntryBci ? method->code() : method->lookup_osr_nmethod_for(osr_bci);

  1092 }

  1095 // ------------------------------------------------------------------

  1096 // CompileBroker::compilation_is_complete

  1097 //

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

  1099 bool CompileBroker::compilation_is_complete(methodHandle method,

  1100                                             int          osr_bci,

  1101                                             int          comp_level) {

  1102   bool is_osr = (osr_bci != standard_entry_bci);

  1103   if (is_osr) {

  1104     if (method->is_not_osr_compilable()) {

  1105       return true;

  1106     } else {

  1107       nmethod* result = method->lookup_osr_nmethod_for(osr_bci);

  1108       return (result != NULL);

  1109     }

  1110   } else {

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

  1112       return true;

  1113     } else {

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

  1115       if (result == NULL) return false;

  1116 #ifdef TIERED

  1117       if (comp_level == CompLevel_fast_compile) {

  1118         // At worst the code is from c1

  1119         return true;

  1120       }

  1121       // comp level must be full opt

  1122       return result->is_compiled_by_c2();

  1123 #endif // TIERED

  1124       return true;

  1125     }

  1126   }

  1127 }

  1130 // ------------------------------------------------------------------

  1131 // CompileBroker::compilation_is_in_queue

  1132 //

  1133 // See if this compilation is already requested.

  1134 //

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

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

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

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

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

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

  1141 bool CompileBroker::compilation_is_in_queue(methodHandle method,

  1142                                           int          osr_bci) {

  1143   return method->queued_for_compilation();

  1144 }

  1147 // ------------------------------------------------------------------

  1148 // CompileBroker::compilation_is_prohibited

  1149 //

  1150 // See if this compilation is not allowed.

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

  1152   bool is_native = method->is_native();

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

  1154   // QQQ this needs some work ought to only record not compilable at

  1155   // the specified level

  1156   if (is_native &&

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

  1158     method->set_not_compilable_quietly();

  1159     return true;

  1160   }

  1162   bool is_osr = (osr_bci != standard_entry_bci);

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

  1164   if (is_osr &&

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

  1166     method->set_not_osr_compilable();

  1167     return true;

  1168   }

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

  1171   bool quietly;

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

  1173     if (!quietly) {

  1174       // This does not happen quietly...

  1175       ResourceMark rm;

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

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

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

  1179       method->print_short_name(tty);

  1180       tty->cr();

  1181     }

  1182     method->set_not_compilable_quietly();

  1183   }

  1185   return false;

  1186 }

  1189 // ------------------------------------------------------------------

  1190 // CompileBroker::assign_compile_id

  1191 //

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

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

  1194 // compilations may be numbered separately from regular compilations

  1195 // if certain debugging flags are used.

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

  1197   assert(_method_queue->lock()->owner() == JavaThread::current(),

  1198          "must hold the compilation queue lock");

  1199   bool is_osr = (osr_bci != standard_entry_bci);

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

  1201   uint id;

  1202   if (CICountOSR && is_osr) {

  1203     id = ++_osr_compilation_id;

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

  1205       return id;

  1206     }

  1207   } else {

  1208     id = ++_compilation_id;

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

  1210       return id;

  1211     }

  1212   }

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

  1215   method->set_not_compilable_quietly();

  1216   return 0;

  1217 }

  1220 // ------------------------------------------------------------------

  1221 // CompileBroker::is_compile_blocking

  1222 //

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

  1224 // has been fulfilled?

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

  1226   return !BackgroundCompilation;

  1227 }

  1230 // ------------------------------------------------------------------

  1231 // CompileBroker::preload_classes

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

  1233   // Move this code over from c1_Compiler.cpp

  1234   ShouldNotReachHere();

  1235 }

  1238 // ------------------------------------------------------------------

  1239 // CompileBroker::create_compile_task

  1240 //

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

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

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

  1244                                               int           compile_id,

  1245                                               methodHandle  method,

  1246                                               int           osr_bci,

  1247                                               int           comp_level,

  1248                                               methodHandle  hot_method,

  1249                                               int           hot_count,

  1250                                               const char*   comment,

  1251                                               bool          blocking) {

  1252   CompileTask* new_task = allocate_task();

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

  1254                        hot_method, hot_count, comment,

  1255                        blocking);

  1256   queue->add(new_task);

  1257   return new_task;

  1258 }

  1261 // ------------------------------------------------------------------

  1262 // CompileBroker::allocate_task

  1263 //

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

  1265 CompileTask* CompileBroker::allocate_task() {

  1266   MutexLocker locker(CompileTaskAlloc_lock);

  1267   CompileTask* task = NULL;

  1268   if (_task_free_list != NULL) {

  1269     task = _task_free_list;

  1270     _task_free_list = task->next();

  1271     task->set_next(NULL);

  1272   } else {

  1273     task = new CompileTask();

  1274     task->set_next(NULL);

  1275   }

  1276   return task;

  1277 }

  1280 // ------------------------------------------------------------------

  1281 // CompileBroker::free_task

  1282 //

  1283 // Add a task to the free list.

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

  1285   MutexLocker locker(CompileTaskAlloc_lock);

  1286   task->free();

  1287   task->set_next(_task_free_list);

  1288   _task_free_list = task;

  1289 }

  1292 // ------------------------------------------------------------------

  1293 // CompileBroker::wait_for_completion

  1294 //

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

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

  1297   if (CIPrintCompileQueue) {

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

  1299   }

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

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

  1304   thread->set_blocked_on_compilation(true);

  1306   methodHandle method(thread,

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

  1308   {

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

  1311     while (!task->is_complete())

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

  1313   }

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

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

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

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

  1319   thread->set_blocked_on_compilation(false);

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

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

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

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

  1325   free_task(task);

  1326 }

  1328 // ------------------------------------------------------------------

  1329 // CompileBroker::compiler_thread_loop

  1330 //

  1331 // The main loop run by a CompilerThread.

  1332 void CompileBroker::compiler_thread_loop() {

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

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

  1336   // For the thread that initializes the ciObjectFactory

  1337   // this resource mark holds all the shared objects

  1338   ResourceMark rm;

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

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

  1343     ASSERT_IN_VM;

  1344     MutexLocker only_one (CompileThread_lock, thread);

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

  1346       ciObjectFactory::initialize();

  1347     }

  1348   }

  1350   // Open a log.

  1351   if (LogCompilation) {

  1352     init_compiler_thread_log();

  1353   }

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

  1355   if (log != NULL) {

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

  1357                     os::current_thread_id(),

  1358                     os::current_process_id());

  1359     log->stamp();

  1360     log->end_elem();

  1361   }

  1363   while (true) {

  1364     {

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

  1366       HandleMark hm(thread);

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

  1369         // the code cache is really full

  1370         handle_full_code_cache();

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

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

  1373         NMethodSweeper::handle_full_code_cache(false);

  1374       }

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

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

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

  1380       if( CompilerThreadHintNoPreempt )

  1381         os::hint_no_preempt();

  1383       // trace per thread time and compile statistics

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

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

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

  1388       // thread as active for the profiler.

  1389       CompileTaskWrapper ctw(task);

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

  1391       task->set_code_handle(&result_handle);

  1392       methodHandle method(thread,

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

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

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

  1397         // Compile the method.

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

  1399 #ifdef COMPILER1

  1400           // Allow repeating compilations for the purpose of benchmarking

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

  1402           if (CompilationRepeat != 0) {

  1403             int compile_count = CompilationRepeat;

  1404             while (compile_count > 0) {

  1405               invoke_compiler_on_method(task);

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

  1407               if (nm != NULL) {

  1408                 nm->make_zombie();

  1409                 method->clear_code();

  1410               }

  1411               compile_count--;

  1412             }

  1413           }

  1414 #endif /* COMPILER1 */

  1415           invoke_compiler_on_method(task);

  1416         } else {

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

  1418           method->clear_queued_for_compilation();

  1419         }

  1420       }

  1421     }

  1422   }

  1423 }

  1426 // ------------------------------------------------------------------

  1427 // CompileBroker::init_compiler_thread_log

  1428 //

  1429 // Set up state required by +LogCompilation.

  1430 void CompileBroker::init_compiler_thread_log() {

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

  1432     char  fileBuf[4*K];

  1433     FILE* fp = NULL;

  1434     char* file = NULL;

  1435     intx thread_id = os::current_thread_id();

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

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

  1438       if (dir == NULL) {

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

  1440                      thread_id, os::current_process_id());

  1441       } else {

  1442         jio_snprintf(fileBuf, sizeof(fileBuf),

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

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

  1445       }

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

  1447       if (fp != NULL) {

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

  1449         strcpy(file, fileBuf);

  1450         break;

  1451       }

  1452     }

  1453     if (fp == NULL) {

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

  1455     } else {

  1456       if (LogCompilation && Verbose)

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

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

  1459       thread->init_log(log);

  1461       if (xtty != NULL) {

  1462         ttyLocker ttyl;

  1464         // Record any per thread log files

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

  1466       }

  1467     }

  1468 }

  1470 // ------------------------------------------------------------------

  1471 // CompileBroker::set_should_block

  1472 //

  1473 // Set _should_block.

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

  1475 void CompileBroker::set_should_block() {

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

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

  1478 #ifndef PRODUCT

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

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

  1481 #endif

  1482   _should_block = true;

  1483 }

  1485 // ------------------------------------------------------------------

  1486 // CompileBroker::maybe_block

  1487 //

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

  1489 void CompileBroker::maybe_block() {

  1490   if (_should_block) {

  1491 #ifndef PRODUCT

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

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

  1494 #endif

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

  1496   }

  1497 }

  1500 // ------------------------------------------------------------------

  1501 // CompileBroker::invoke_compiler_on_method

  1502 //

  1503 // Compile a method.

  1504 //

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

  1506   if (PrintCompilation) {

  1507     ResourceMark rm;

  1508     task->print_line();

  1509   }

  1510   elapsedTimer time;

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

  1513   ResourceMark rm(thread);

  1515   // Common flags.

  1516   uint compile_id = task->compile_id();

  1517   int osr_bci = task->osr_bci();

  1518   bool is_osr = (osr_bci != standard_entry_bci);

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

  1520   bool should_break = false;

  1521   {

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

  1523     // accidentally be referenced once the thread transitions to

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

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

  1526     methodHandle method(thread,

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

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

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

  1530       should_log = false;

  1531     }

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

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

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

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

  1538   }

  1540   // Allocate a new set of JNI handles.

  1541   push_jni_handle_block();

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

  1543   int compilable = ciEnv::MethodCompilable;

  1544   {

  1545     int system_dictionary_modification_counter;

  1546     {

  1547       MutexLocker locker(Compile_lock, thread);

  1548       system_dictionary_modification_counter = SystemDictionary::number_of_modifications();

  1549     }

  1551     NoHandleMark  nhm;

  1552     ThreadToNativeFromVM ttn(thread);

  1554     ciEnv ci_env(task, system_dictionary_modification_counter);

  1555     if (should_break) {

  1556       ci_env.set_break_at_compile(true);

  1557     }

  1558     if (should_log) {

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

  1560     }

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

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

  1564     // Cache Jvmti state

  1565     ci_env.cache_jvmti_state();

  1567     // Cache DTrace flags

  1568     ci_env.cache_dtrace_flags();

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

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

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

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

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

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

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

  1580       ci_env.record_method_not_compilable("compile failed");

  1581     }

  1583     if (ci_env.failing()) {

  1584       // Copy this bit to the enclosing block:

  1585       compilable = ci_env.compilable();

  1586       if (PrintCompilation) {

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

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

  1589           if (is_highest_tier_compile(ci_env.comp_level())) {

  1590             // Already at highest tier, promote to not compilable.

  1591             compilable = ciEnv::MethodCompilable_never;

  1592           } else {

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

  1594           }

  1595         }

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

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

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

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

  1601         }

  1602       }

  1603     } else {

  1604       task->mark_success();

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

  1606     }

  1607   }

  1608   pop_jni_handle_block();

  1610   methodHandle method(thread,

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

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

  1615   collect_statistics(thread, time, task);

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

  1618     if (is_osr) {

  1619       method->set_not_osr_compilable();

  1620     } else {

  1621       method->set_not_compilable_quietly();

  1622     }

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

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

  1625   }

  1627   // Note that the queued_for_compilation bits are cleared without

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

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

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

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

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

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

  1634   method->clear_queued_for_compilation();

  1636 #ifdef ASSERT

  1637   if (CollectedHeap::fired_fake_oom()) {

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

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

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

  1641     vm_exit(0);

  1642   }

  1643 #endif

  1644 }

  1647 // ------------------------------------------------------------------

  1648 // CompileBroker::handle_full_code_cache

  1649 //

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

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

  1652 void CompileBroker::handle_full_code_cache() {

  1653   UseInterpreter = true;

  1654   if (UseCompiler || AlwaysCompileLoopMethods ) {

  1655     if (xtty != NULL) {

  1656       xtty->begin_elem("code_cache_full");

  1657       xtty->stamp();

  1658       xtty->end_elem();

  1659     }

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

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

  1662 #ifndef PRODUCT

  1663     if (CompileTheWorld || ExitOnFullCodeCache) {

  1664       before_exit(JavaThread::current());

  1665       exit_globals(); // will delete tty

  1666       vm_direct_exit(CompileTheWorld ? 0 : 1);

  1667     }

  1668 #endif

  1669     if (UseCodeCacheFlushing) {

  1670       NMethodSweeper::handle_full_code_cache(true);

  1671     } else {

  1672       UseCompiler               = false;

  1673       AlwaysCompileLoopMethods  = false;

  1674     }

  1675   }

  1676 }

  1678 // ------------------------------------------------------------------

  1679 // CompileBroker::set_last_compile

  1680 //

  1681 // Record this compilation for debugging purposes.

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

  1683   ResourceMark rm;

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

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

  1686   char current_method[CompilerCounters::cmname_buffer_length];

  1687   size_t maxLen = CompilerCounters::cmname_buffer_length;

  1689   if (UsePerfData) {

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

  1692     size_t s1len = strlen(class_name);

  1693     size_t s2len = strlen(method_name);

  1695     // check if we need to truncate the string

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

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

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

  1701       if (s2len + 2 > maxLen) {

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

  1703         // truncation of the method name.

  1704         class_name += s1len; // null string

  1705       }

  1706       else {

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

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

  1709       }

  1710     }

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

  1713   }

  1715   if (CICountOSR && is_osr) {

  1716     _last_compile_type = osr_compile;

  1717   } else {

  1718     _last_compile_type = normal_compile;

  1719   }

  1720   _last_compile_level = comp_level;

  1722   if (UsePerfData) {

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

  1724     counters->set_current_method(current_method);

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

  1726   }

  1727 }

  1730 // ------------------------------------------------------------------

  1731 // CompileBroker::push_jni_handle_block

  1732 //

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

  1734 void CompileBroker::push_jni_handle_block() {

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

  1737   // Allocate a new block for JNI handles.

  1738   // Inlined code from jni_PushLocalFrame()

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

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

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

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

  1743   thread->set_active_handles(compile_handles);

  1744 }

  1747 // ------------------------------------------------------------------

  1748 // CompileBroker::pop_jni_handle_block

  1749 //

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

  1751 void CompileBroker::pop_jni_handle_block() {

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

  1754   // Release our JNI handle block

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

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

  1757   thread->set_active_handles(java_handles);

  1758   compile_handles->set_pop_frame_link(NULL);

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

  1760 }

  1763 // ------------------------------------------------------------------

  1764 // CompileBroker::check_break_at

  1765 //

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

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

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

  1769     return true;

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

  1771     return true;

  1772   } else {

  1773     return (compile_id == CIBreakAt);

  1774   }

  1775 }

  1777 // ------------------------------------------------------------------

  1778 // CompileBroker::collect_statistics

  1779 //

  1780 // Collect statistics about the compilation.

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

  1783   bool success = task->is_success();

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

  1785   uint compile_id = task->compile_id();

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

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

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

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

  1791   MutexLocker locker(CompileStatistics_lock);

  1793   // _perf variables are production performance counters which are

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

  1795   //

  1796   if (!success) {

  1797     _total_bailout_count++;

  1798     if (UsePerfData) {

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

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

  1801       _perf_total_bailout_count->inc();

  1802     }

  1803   } else if (code == NULL) {

  1804     if (UsePerfData) {

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

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

  1807       _perf_total_invalidated_count->inc();

  1808     }

  1809     _total_invalidated_count++;

  1810   } else {

  1811     // Compilation succeeded

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

  1814     // java.lang.management.CompilationMBean

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

  1817     if (CITime) {

  1818       _t_total_compilation.add(time);

  1819       if (is_osr) {

  1820         _t_osr_compilation.add(time);

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

  1822       } else {

  1823         _t_standard_compilation.add(time);

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

  1825       }

  1826     }

  1828     if (UsePerfData) {

  1829       // save the name of the last method compiled

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

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

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

  1833                                          task->num_inlined_bytecodes());

  1834       if (is_osr) {

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

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

  1837       } else {

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

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

  1840       }

  1841     }

  1843     if (CITimeEach) {

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

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

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

  1847     }

  1849     // Collect counts of successful compilations

  1850     _sum_nmethod_size      += code->total_size();

  1851     _sum_nmethod_code_size += code->insts_size();

  1852     _total_compile_count++;

  1854     if (UsePerfData) {

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

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

  1857       _perf_total_compile_count->inc();

  1858     }

  1860     if (is_osr) {

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

  1862       _total_osr_compile_count++;

  1863     } else {

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

  1865       _total_standard_compile_count++;

  1866     }

  1867   }

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

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

  1870 }

  1874 void CompileBroker::print_times() {

  1875   tty->cr();

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

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

  1878                //0000000000111111111122222222223333333333444444444455555555556666666666

  1879                //0123456789012345678901234567890123456789012345678901234567890123456789

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

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

  1882                 CompileBroker::_t_standard_compilation.seconds(),

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

  1884   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);

  1886   if (compiler(CompLevel_fast_compile)) {

  1887     compiler(CompLevel_fast_compile)->print_timers();

  1888     if (compiler(CompLevel_fast_compile) != compiler(CompLevel_highest_tier))

  1889       compiler(CompLevel_highest_tier)->print_timers();

  1890   }

  1892   tty->cr();

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

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

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

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

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

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

  1899   tty->cr();

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

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

  1902 }

  1905 // Debugging output for failure

  1906 void CompileBroker::print_last_compile() {

  1907   if ( _last_compile_level != CompLevel_none &&

  1908        compiler(_last_compile_level) != NULL &&

  1909        _last_method_compiled != NULL &&

  1910        _last_compile_type != no_compile) {

  1911     if (_last_compile_type == osr_compile) {

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

  1913                     _osr_compilation_id, _last_compile_level, _last_method_compiled);

  1914     } else {

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

  1916                     _compilation_id, _last_compile_level, _last_method_compiled);

  1917     }

  1918   }

  1919 }

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

  1923 #ifndef PRODUCT

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

  1925   st->cr();

  1926 #endif

  1927 }

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

src/share/vm/compiler/compileBroker.cpp@3e8fbc61cee8

src/share/vm/compiler/compileBroker.cpp