/*

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

 *

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

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

 * published by the Free Software Foundation.

 *

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

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

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_compileBroker.cpp.incl"

#ifdef DTRACE_ENABLED

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

HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin,

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

HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end,

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

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)              \

  {                                                                      \

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

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

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

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

    HS_DTRACE_PROBE8(hotspot, method__compile__begin,                    \

      comp_name, strlen(comp_name),                                      \

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

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

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

  }

#define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)       \

  {                                                                      \

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

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

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

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

    HS_DTRACE_PROBE9(hotspot, method__compile__end,                      \

      comp_name, strlen(comp_name),                                      \

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

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

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

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)

#define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)

#endif // ndef DTRACE_ENABLED

bool CompileBroker::_initialized = false;

volatile bool CompileBroker::_should_block = false;

// The installed compiler(s)

AbstractCompiler* CompileBroker::_compilers[2];

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

uint CompileBroker::_compilation_id        = 0;

uint CompileBroker::_osr_compilation_id    = 0;

// Debugging information

int  CompileBroker::_last_compile_type     = no_compile;

int  CompileBroker::_last_compile_level    = CompLevel_none;

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

// Performance counters

PerfCounter* CompileBroker::_perf_total_compilation = NULL;

PerfCounter* CompileBroker::_perf_osr_compilation = NULL;

PerfCounter* CompileBroker::_perf_standard_compilation = NULL;

PerfCounter* CompileBroker::_perf_total_bailout_count = NULL;

PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL;

PerfCounter* CompileBroker::_perf_total_compile_count = NULL;

PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL;

PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL;

PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL;

PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL;

PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL;

PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL;

PerfStringVariable* CompileBroker::_perf_last_method = NULL;

PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL;

PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL;

PerfVariable*       CompileBroker::_perf_last_compile_type = NULL;

PerfVariable*       CompileBroker::_perf_last_compile_size = NULL;

PerfVariable*       CompileBroker::_perf_last_failed_type = NULL;

PerfVariable*       CompileBroker::_perf_last_invalidated_type = NULL;

// Timers and counters for generating statistics

elapsedTimer CompileBroker::_t_total_compilation;

elapsedTimer CompileBroker::_t_osr_compilation;

elapsedTimer CompileBroker::_t_standard_compilation;

int CompileBroker::_total_bailout_count          = 0;

int CompileBroker::_total_invalidated_count      = 0;

int CompileBroker::_total_compile_count          = 0;

int CompileBroker::_total_osr_compile_count      = 0;

int CompileBroker::_total_standard_compile_count = 0;

int CompileBroker::_sum_osr_bytes_compiled       = 0;

int CompileBroker::_sum_standard_bytes_compiled  = 0;

int CompileBroker::_sum_nmethod_size             = 0;

int CompileBroker::_sum_nmethod_code_size        = 0;

CompileQueue* CompileBroker::_method_queue   = NULL;

CompileTask*  CompileBroker::_task_free_list = NULL;

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

// CompileTaskWrapper

//

// Assign this task to the current thread.  Deallocate the task

// when the compilation is complete.

class CompileTaskWrapper : StackObj {

public:

  CompileTaskWrapper(CompileTask* task);

  ~CompileTaskWrapper();

};

CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {

  CompilerThread* thread = CompilerThread::current();

  thread->set_task(task);

  CompileLog*     log  = thread->log();

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

}

CompileTaskWrapper::~CompileTaskWrapper() {

  CompilerThread* thread = CompilerThread::current();

  CompileTask* task = thread->task();

  CompileLog*  log  = thread->log();

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

  thread->set_task(NULL);

  task->set_code_handle(NULL);

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

  if (task->is_blocking()) {

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

    task->mark_complete();

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

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

  } else {

    task->mark_complete();

    // By convention, the compiling thread is responsible for

    // recycling a non-blocking CompileTask.

    CompileBroker::free_task(task);

  }

}

// ------------------------------------------------------------------

// CompileTask::initialize

void CompileTask::initialize(int compile_id,

                             methodHandle method,

                             int osr_bci,

                             int comp_level,

                             methodHandle hot_method,

                             int hot_count,

                             const char* comment,

                             bool is_blocking) {

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

  _compile_id = compile_id;

  _method = JNIHandles::make_global(method);

  _osr_bci = osr_bci;

  _is_blocking = is_blocking;

  _comp_level = comp_level;

  _num_inlined_bytecodes = 0;

  _is_complete = false;

  _is_success = false;

  _code_handle = NULL;

  _hot_method = NULL;

  _hot_count = hot_count;

  _time_queued = 0;  // tidy

  _comment = comment;

  if (LogCompilation) {

    _time_queued = os::elapsed_counter();

    if (hot_method.not_null()) {

      if (hot_method == method) {

        _hot_method = _method;

      } else {

        _hot_method = JNIHandles::make_global(hot_method);

      }

    }

  }

  _next = NULL;

}

// ------------------------------------------------------------------

// CompileTask::code/set_code

nmethod* CompileTask::code() const {

  if (_code_handle == NULL)  return NULL;

  return _code_handle->code();

}

void CompileTask::set_code(nmethod* nm) {

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

  guarantee(_code_handle != NULL, "");

  _code_handle->set_code(nm);

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

}

// ------------------------------------------------------------------

// CompileTask::free

void CompileTask::free() {

  set_code(NULL);

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

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

    JNIHandles::destroy_global(_hot_method);

  }

  JNIHandles::destroy_global(_method);

}

// ------------------------------------------------------------------

// CompileTask::print

void CompileTask::print() {

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

  tty->print("method=");

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

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

             _osr_bci, bool_to_str(_is_blocking),

             bool_to_str(_is_complete), bool_to_str(_is_success));

}

// ------------------------------------------------------------------

// CompileTask::print_line_on_error

//

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

// causing troubles is a compiler thread.

//

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

//

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

//

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

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

  // print compiler name

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

  // print compilation number

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

  // print method attributes

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

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

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

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

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

    const char tier_char      =

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

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

  }

  // Use buf to get method name and signature

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

  // print osr_bci if any

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

  // print method size

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

}

// ------------------------------------------------------------------

// CompileTask::print_line

void CompileTask::print_line() {

  Thread *thread = Thread::current();

  methodHandle method(thread,

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

  ResourceMark rm(thread);

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

  // print compiler name if requested

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

  // print compilation number

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

  // print method attributes

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

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

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

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

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

    const char tier_char      =

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

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

  }

  // print method name

  method->print_short_name(tty);

  // print osr_bci if any

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

  // print method size

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

}

// ------------------------------------------------------------------

// CompileTask::log_task

void CompileTask::log_task(xmlStream* log) {

  Thread* thread = Thread::current();

  methodHandle method(thread,

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

  ResourceMark rm(thread);

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

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

  if (_osr_bci != CompileBroker::standard_entry_bci) {

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

  } // else compile_kind='c2c'

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

  if (_osr_bci != CompileBroker::standard_entry_bci) {

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

  }

  if (_comp_level != CompLevel_highest_tier) {

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

  }

  if (_is_blocking) {

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

  }

  log->stamp();

}

// ------------------------------------------------------------------

// CompileTask::log_task_queued

void CompileTask::log_task_queued() {

  Thread* thread = Thread::current();

  ttyLocker ttyl;

  ResourceMark rm(thread);

  xtty->begin_elem("task_queued");

  log_task(xtty);

  if (_comment != NULL) {

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

  }

  if (_hot_method != NULL) {

    methodHandle hot(thread,

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

    methodHandle method(thread,

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

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

      xtty->method(hot);

    }

  }

  if (_hot_count != 0) {

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

  }

  xtty->end_elem();

}

// ------------------------------------------------------------------

// CompileTask::log_task_start

void CompileTask::log_task_start(CompileLog* log)   {

  log->begin_head("task");

  log_task(log);

  log->end_head();

}

// ------------------------------------------------------------------

// CompileTask::log_task_done

void CompileTask::log_task_done(CompileLog* log) {

  Thread* thread = Thread::current();

  methodHandle method(thread,

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

  ResourceMark rm(thread);

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

  nmethod* nm = code();

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

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

                  method->invocation_count());

  int bec = method->backedge_count();

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

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

  if (_num_inlined_bytecodes != 0) {

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

  }

  log->stamp();

  log->end_elem();

  log->tail("task");

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

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

    log->flush();

  }

  log->mark_file_end();

}

// ------------------------------------------------------------------

// CompileQueue::add

//

// Add a CompileTask to a CompileQueue

void CompileQueue::add(CompileTask* task) {

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

  task->set_next(NULL);

  if (_last == NULL) {

    // The compile queue is empty.

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

    _first = task;

    _last = task;

  } else {

    // Append the task to the queue.

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

    _last->set_next(task);

    _last = task;

  }

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

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

  if (CIPrintCompileQueue) {

    print();

  }

  if (LogCompilation && xtty != NULL) {

    task->log_task_queued();

  }

  // Notify CompilerThreads that a task is available.

  lock()->notify();

}

// ------------------------------------------------------------------

// CompileQueue::get

//

// Get the next CompileTask from a CompileQueue

CompileTask* CompileQueue::get() {

  MutexLocker locker(lock());

  // Wait for an available CompileTask.

  while (_first == NULL) {

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

    lock()->wait();

  }

  CompileTask* task = _first;

  // Update queue first and last

  _first =_first->next();

  if (_first == NULL) {

    _last = NULL;

  }

  return task;

}

// ------------------------------------------------------------------

// CompileQueue::print

void CompileQueue::print() {

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

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

  CompileTask* task = _first;

  while (task != NULL) {

    task->print_line();

    task = task->next();

  }

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

}

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

  _current_method[0] = '\0';

  _compile_type = CompileBroker::no_compile;

  if (UsePerfData) {

    ResourceMark rm;

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

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

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

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

                      PerfDataManager::name_space(thread_name, instance);

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

    _perf_current_method =

               PerfDataManager::create_string_variable(SUN_CI, name,

                                                       cmname_buffer_length,

                                                       _current_method, CHECK);

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

    _perf_compile_type = PerfDataManager::create_variable(SUN_CI, name,

                                                          PerfData::U_None,

                                                         (jlong)_compile_type,

                                                          CHECK);

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

    _perf_time = PerfDataManager::create_counter(SUN_CI, name,

                                                 PerfData::U_Ticks, CHECK);

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