/*

 * Copyright (c) 1999, 2019, 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/compilationPolicy.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/compilerOracle.hpp"

#include "compiler/directivesParser.hpp"

#include "interpreter/linkResolver.hpp"

#include "jfr/jfrEvents.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.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/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniHandles.inline.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 "utilities/debug.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/formatBuffer.hpp"

#include "utilities/macros.hpp"

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#if INCLUDE_JVMCI

#include "jvmci/jvmciEnv.hpp"

#include "jvmci/jvmciRuntime.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];

// The maximum numbers of compiler threads to be determined during startup.

int CompileBroker::_c1_count = 0;

int CompileBroker::_c2_count = 0;

// An array of compiler names as Java String objects

jobject* CompileBroker::_compiler1_objects = NULL;

jobject* CompileBroker::_compiler2_objects = NULL;

CompileLog** CompileBroker::_compiler1_logs = NULL;

CompileLog** CompileBroker::_compiler2_logs = NULL;

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

// 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::_total_compiler_stopped_count   = 0;

int CompileBroker::_total_compiler_restarted_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", "jit") {

  }

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

    StringLogMessage lm;

    stringStream sstr(lm.buffer(), lm.size());

    // 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->is_unloaded())  task->log_task_start(log);

}

CompileTaskWrapper::~CompileTaskWrapper() {

  CompilerThread* thread = CompilerThread::current();

  CompileTask* task = thread->task();

  CompileLog*  log  = thread->log();

  if (log != NULL && !task->is_unloaded())  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);

  }

}

/**

 * Check if a CompilerThread can be removed and update count if requested.

 */

bool CompileBroker::can_remove(CompilerThread *ct, bool do_it) {

  assert(UseDynamicNumberOfCompilerThreads, "or shouldn't be here");

  if (!ReduceNumberOfCompilerThreads) return false;

  AbstractCompiler *compiler = ct->compiler();

  int compiler_count = compiler->num_compiler_threads();

  bool c1 = compiler->is_c1();

  // Keep at least 1 compiler thread of each type.

  if (compiler_count < 2) return false;

  // Keep thread alive for at least some time.

  if (ct->idle_time_millis() < (c1 ? 500 : 100)) return false;

#if INCLUDE_JVMCI

  if (compiler->is_jvmci()) {

    // Handles for JVMCI thread objects may get released concurrently.

    if (do_it) {

      assert(CompileThread_lock->owner() == ct, "must be holding lock");

    } else {

      // Skip check if it's the last thread and let caller check again.

      return true;

    }

  }

#endif

  // We only allow the last compiler thread of each type to get removed.

  jobject last_compiler = c1 ? compiler1_object(compiler_count - 1)

                             : compiler2_object(compiler_count - 1);

  if (ct->threadObj() == JNIHandles::resolve_non_null(last_compiler)) {

    if (do_it) {

      assert_locked_or_safepoint(CompileThread_lock); // Update must be consistent.

      compiler->set_num_compiler_threads(compiler_count - 1);

#if INCLUDE_JVMCI

      if (compiler->is_jvmci()) {

        // Old j.l.Thread object can die when no longer referenced elsewhere.

        JNIHandles::destroy_global(compiler2_object(compiler_count - 1));

        _compiler2_objects[compiler_count - 1] = NULL;

      }

#endif

    }

    return true;

  }

  return false;

}

/**

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

  MonitorLocker 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.

    locker.wait(5*1000);

    if (UseDynamicNumberOfCompilerThreads && _first == NULL) {

      // Still nothing to compile. Give caller a chance to stop this thread.

      if (CompileBroker::can_remove(CompilerThread::current(), false)) return NULL;

    }

  }

  if (CompileBroker::is_compilation_disabled_forever()) {

    return NULL;

  }

  CompileTask* task;

  {

    NoSafepointVerifier nsv;

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

    if (task != NULL) {

      task = task->select_for_compilation();

    }

  }

  if (task != NULL) {

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

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

    Thread* thread = Thread::current();

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

    save_hot_method = methodHandle(thread, 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();