/*

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

 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "jvm.h"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "code/codeHeapState.hpp"

#include "code/dependencyContext.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/compilerOracle.hpp"

#include "compiler/directivesParser.hpp"

#include "interpreter/linkResolver.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "oops/methodData.hpp"

#include "oops/method.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/nativeLookup.hpp"

#include "prims/whitebox.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/os.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/sweeper.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/vframe.inline.hpp"

#include "trace/tracing.hpp"

#include "utilities/debug.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/formatBuffer.hpp"

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#if INCLUDE_JVMCI

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "jvmci/jvmciJavaClasses.hpp"

#include "runtime/vframe.hpp"

#endif

#ifdef COMPILER2

#include "opto/c2compiler.hpp"

#endif

#ifdef DTRACE_ENABLED

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

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)             \

  {                                                                      \

    Symbol* klass_name = (method)->klass_name();                         \

    Symbol* name = (method)->name();                                     \

    Symbol* signature = (method)->signature();                           \

    HOTSPOT_METHOD_COMPILE_BEGIN(                                        \

      (char *) comp_name, strlen(comp_name),                             \

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

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

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

  }

#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success)      \

  {                                                                      \

    Symbol* klass_name = (method)->klass_name();                         \

    Symbol* name = (method)->name();                                     \

    Symbol* signature = (method)->signature();                           \

    HOTSPOT_METHOD_COMPILE_END(                                          \

      (char *) comp_name, strlen(comp_name),                             \

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

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

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

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)

#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success)

#endif // ndef DTRACE_ENABLED

bool CompileBroker::_initialized = false;

volatile bool CompileBroker::_should_block = false;

volatile int  CompileBroker::_print_compilation_warning = 0;

volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;

// The installed compiler(s)

AbstractCompiler* CompileBroker::_compilers[2];

// These counters are used to assign an unique ID to each compilation.

volatile jint CompileBroker::_compilation_id     = 0;

volatile jint 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;

elapsedTimer CompileBroker::_t_invalidated_compilation;

elapsedTimer CompileBroker::_t_bailedout_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;

long CompileBroker::_peak_compilation_time       = 0;

CompileQueue* CompileBroker::_c2_compile_queue   = NULL;

CompileQueue* CompileBroker::_c1_compile_queue   = NULL;

class CompilationLog : public StringEventLog {

 public:

  CompilationLog() : StringEventLog("Compilation events") {

  }

  void log_compile(JavaThread* thread, CompileTask* task) {

    StringLogMessage lm;

    stringStream sstr = lm.stream();

    // msg.time_stamp().update_to(tty->time_stamp().ticks());

    task->print(&sstr, NULL, true, false);

    log(thread, "%s", (const char*)lm);

  }

  void log_nmethod(JavaThread* thread, nmethod* nm) {

    log(thread, "nmethod %d%s " INTPTR_FORMAT " code [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",

        nm->compile_id(), nm->is_osr_method() ? "%" : "",

        p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end()));

  }

  void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) {

    StringLogMessage lm;

    lm.print("%4d   COMPILE SKIPPED: %s", task->compile_id(), reason);

    if (retry_message != NULL) {

      lm.append(" (%s)", retry_message);

    }

    lm.print("\n");

    log(thread, "%s", (const char*)lm);

  }

  void log_metaspace_failure(const char* reason) {

    ResourceMark rm;

    StringLogMessage lm;

    lm.print("%4d   COMPILE PROFILING SKIPPED: %s", -1, reason);

    lm.print("\n");

    log(JavaThread::current(), "%s", (const char*)lm);

  }

};

static CompilationLog* _compilation_log = NULL;

bool compileBroker_init() {

  if (LogEvents) {

    _compilation_log = new CompilationLog();

  }

  // init directives stack, adding default directive

  DirectivesStack::init();

  if (DirectivesParser::has_file()) {

    return DirectivesParser::parse_from_flag();

  } else if (CompilerDirectivesPrint) {

    // Print default directive even when no other was added

    DirectivesStack::print(tty);

  }

  return true;

}

CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {

  CompilerThread* thread = CompilerThread::current();

  thread->set_task(task);

#if INCLUDE_JVMCI

  if (task->is_blocking() && CompileBroker::compiler(task->comp_level())->is_jvmci()) {

    task->set_jvmci_compiler_thread(thread);

  }

#endif

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

  thread->set_env(NULL);

  if (task->is_blocking()) {

    bool free_task = false;

    {

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

      task->mark_complete();

#if INCLUDE_JVMCI

      if (CompileBroker::compiler(task->comp_level())->is_jvmci()) {

        if (!task->has_waiter()) {

          // The waiting thread timed out and thus did not free the task.

          free_task = true;

        }

        task->set_jvmci_compiler_thread(NULL);

      }

#endif

      if (!free_task) {

        // Notify the waiting thread that the compilation has completed

        // so that it can free the task.

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

      }

    }

    if (free_task) {

      // The task can only be freed once the task lock is released.

      CompileTask::free(task);

    }

  } else {

    task->mark_complete();

    // By convention, the compiling thread is responsible for

    // recycling a non-blocking CompileTask.

    CompileTask::free(task);

  }

}

/**

 * Add a CompileTask to a CompileQueue.

 */

void CompileQueue::add(CompileTask* task) {

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

  task->set_next(NULL);

  task->set_prev(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);

    task->set_prev(_last);

    _last = task;

  }

  ++_size;

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

  task->method()->set_queued_for_compilation();

  if (CIPrintCompileQueue) {

    print_tty();

  }

  if (LogCompilation && xtty != NULL) {

    task->log_task_queued();

  }

  // Notify CompilerThreads that a task is available.

  MethodCompileQueue_lock->notify_all();

}

/**

 * Empties compilation queue by putting all compilation tasks onto

 * a freelist. Furthermore, the method wakes up all threads that are

 * waiting on a compilation task to finish. This can happen if background

 * compilation is disabled.

 */

void CompileQueue::free_all() {

  MutexLocker mu(MethodCompileQueue_lock);

  CompileTask* next = _first;

  // Iterate over all tasks in the compile queue

  while (next != NULL) {

    CompileTask* current = next;

    next = current->next();

    {

      // Wake up thread that blocks on the compile task.

      MutexLocker ct_lock(current->lock());

      current->lock()->notify();

    }

    // Put the task back on the freelist.

    CompileTask::free(current);

  }

  _first = NULL;

  // Wake up all threads that block on the queue.

  MethodCompileQueue_lock->notify_all();

}

/**

 * Get the next CompileTask from a CompileQueue

 */

CompileTask* CompileQueue::get() {

  // save methods from RedefineClasses across safepoint

  // across MethodCompileQueue_lock below.

  methodHandle save_method;

  methodHandle save_hot_method;

  MutexLocker locker(MethodCompileQueue_lock);

  // If _first is NULL we have no more compile jobs. There are two reasons for

  // having no compile jobs: First, we compiled everything we wanted. Second,

  // we ran out of code cache so compilation has been disabled. In the latter

  // case we perform code cache sweeps to free memory such that we can re-enable

  // compilation.

  while (_first == NULL) {

    // Exit loop if compilation is disabled forever

    if (CompileBroker::is_compilation_disabled_forever()) {

      return NULL;

    }

    // If there are no compilation tasks and we can compile new jobs

    // (i.e., there is enough free space in the code cache) there is

    // no need to invoke the sweeper. As a result, the hotness of methods

    // remains unchanged. This behavior is desired, since we want to keep

    // the stable state, i.e., we do not want to evict methods from the

    // code cache if it is unnecessary.

    // We need a timed wait here, since compiler threads can exit if compilation

    // is disabled forever. We use 5 seconds wait time; the exiting of compiler threads

    // is not critical and we do not want idle compiler threads to wake up too often.

    MethodCompileQueue_lock->wait(!Mutex::_no_safepoint_check_flag, 5*1000);

  }

  if (CompileBroker::is_compilation_disabled_forever()) {

    return NULL;

  }

  CompileTask* task;

  {

    NoSafepointVerifier nsv;

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

  }

  if (task != NULL) {

    // Save method pointers across unlock safepoint.  The task is removed from

    // the compilation queue, which is walked during RedefineClasses.

    save_method = methodHandle(task->method());

    save_hot_method = methodHandle(task->hot_method());

    remove(task);

    purge_stale_tasks(); // may temporarily release MCQ lock

  }

  return task;

}

// Clean & deallocate stale compile tasks.

// Temporarily releases MethodCompileQueue lock.

void CompileQueue::purge_stale_tasks() {

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

  if (_first_stale != NULL) {

    // Stale tasks are purged when MCQ lock is released,

    // but _first_stale updates are protected by MCQ lock.

    // Once task processing starts and MCQ lock is released,

    // other compiler threads can reuse _first_stale.

    CompileTask* head = _first_stale;

    _first_stale = NULL;

    {

      MutexUnlocker ul(MethodCompileQueue_lock);

      for (CompileTask* task = head; task != NULL; ) {

        CompileTask* next_task = task->next();

        CompileTaskWrapper ctw(task); // Frees the task

        task->set_failure_reason("stale task");

        task = next_task;

      }

    }

  }

}

void CompileQueue::remove(CompileTask* task) {

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

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

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

  } else {

    // max is the first element

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

    _first = task->next();

  }

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

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

  } else {

    // max is the last element

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

    _last = task->prev();

  }

  --_size;

}

void CompileQueue::remove_and_mark_stale(CompileTask* task) {

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

  remove(task);

  // Enqueue the task for reclamation (should be done outside MCQ lock)

  task->set_next(_first_stale);

  task->set_prev(NULL);

  _first_stale = task;

}

// methods in the compile queue need to be marked as used on the stack

// so that they don't get reclaimed by Redefine Classes

void CompileQueue::mark_on_stack() {

  CompileTask* task = _first;

  while (task != NULL) {

    task->mark_on_stack();

    task = task->next();

  }

}

CompileQueue* CompileBroker::compile_queue(int comp_level) {

  if (is_c2_compile(comp_level)) return _c2_compile_queue;

  if (is_c1_compile(comp_level)) return _c1_compile_queue;

  return NULL;

}

void CompileBroker::print_compile_queues(outputStream* st) {

  st->print_cr("Current compiles: ");

  MutexLocker locker(MethodCompileQueue_lock);

  char buf[2000];

  int buflen = sizeof(buf);

  Threads::print_threads_compiling(st, buf, buflen);

  st->cr();

  if (_c1_compile_queue != NULL) {

    _c1_compile_queue->print(st);

  }

  if (_c2_compile_queue != NULL) {

    _c2_compile_queue->print(st);