8231269: CompileTask::is_unloaded is slow due to JNIHandles type checks

src/hotspot/share/ci/ciEnv.cpp

@@ -44,7 +44,7 @@
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerEvent.hpp"
-#include "compiler/compileTask.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "compiler/disassembler.hpp"
 #include "gc/shared/collectedHeap.inline.hpp"
 #include "interpreter/bytecodeStream.hpp"

src/hotspot/share/ci/ciMethod.cpp

@@ -36,7 +36,7 @@
 #include "compiler/abstractCompiler.hpp"
 #include "compiler/compilerDefinitions.inline.hpp"
 #include "compiler/compilerOracle.hpp"
-#include "compiler/compileTask.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "compiler/methodLiveness.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/linkResolver.hpp"

src/hotspot/share/compiler/compilationMemoryStatistic.cpp

@@ -30,7 +30,7 @@
 #include "compiler/compilerDirectives.hpp"
 #include "compiler/compilerOracle.hpp"
 #include "compiler/compilerThread.hpp"
-#include "compiler/compileTask.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 #include "memory/arena.hpp"

src/hotspot/share/compiler/compilationPolicy.cpp

@@ -28,6 +28,7 @@
 #include "compiler/compileBroker.hpp"
 #include "compiler/compilerDefinitions.inline.hpp"
 #include "compiler/compilerOracle.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/method.inline.hpp"
 #include "oops/methodData.hpp"

src/hotspot/share/compiler/compileBroker.cpp

@@ -37,6 +37,7 @@
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerEvent.hpp"
 #include "compiler/compilerOracle.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "compiler/directivesParser.hpp"
 #include "gc/shared/memAllocator.hpp"
 #include "interpreter/linkResolver.hpp"
@@ -1707,7 +1708,8 @@ void CompileBroker::wait_for_completion(CompileTask* task) {
 
   JavaThread* thread = JavaThread::current();
 
-  methodHandle method(thread, task->method());
+  methodHandle method(thread, task->is_unloaded() ? nullptr : task->method());
+
   bool free_task;
 #if INCLUDE_JVMCI
   AbstractCompiler* comp = compiler(task->comp_level());

src/hotspot/share/compiler/compileTask.cpp

@@ -26,12 +26,13 @@
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileLog.hpp"
 #include "compiler/compilerDirectives.hpp"
-#include "compiler/compileTask.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/klass.inline.hpp"
 #include "oops/method.inline.hpp"
+#include "oops/unloadableMethodHandle.inline.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/jniHandles.hpp"
 #include "runtime/mutexLocker.hpp"
@@ -44,11 +45,9 @@ CompileTask::CompileTask(int compile_id,
                          int comp_level,
                          int hot_count,
                          CompileReason compile_reason,
-                         bool is_blocking) {
-  Thread* thread = Thread::current();
+                         bool is_blocking) :
+  _method_handle(method()) {
   _compile_id = compile_id;
-  _method = method();
-  _method_holder = JNIHandles::make_weak_global(Handle(thread, method->method_holder()->klass_holder()));
   _osr_bci = osr_bci;
   _is_blocking = is_blocking;
   JVMCI_ONLY(_has_waiter = CompileBroker::compiler(comp_level)->is_jvmci();)
@@ -81,11 +80,6 @@ CompileTask::CompileTask(int compile_id,
 }
 
 CompileTask::~CompileTask() {
-  if (_method_holder != nullptr && JNIHandles::is_weak_global_handle(_method_holder)) {
-    JNIHandles::destroy_weak_global(_method_holder);
-  } else {
-    JNIHandles::destroy_global(_method_holder);
-  }
   if (_failure_reason_on_C_heap && _failure_reason != nullptr) {
     os::free((void*) _failure_reason);
     _failure_reason = nullptr;
@@ -112,38 +106,36 @@ AbstractCompiler* CompileTask::compiler() const {
   return CompileBroker::compiler(_comp_level);
 }
 
-// Replace weak handles by strong handles to avoid unloading during compilation.
 CompileTask* CompileTask::select_for_compilation() {
-  if (is_unloaded()) {
-    // Guard against concurrent class unloading
-    return nullptr;
-  }
-  Thread* thread = Thread::current();
-  assert(_method->method_holder()->is_loader_alive(), "should be alive");
-  Handle method_holder(thread, _method->method_holder()->klass_holder());
-  JNIHandles::destroy_weak_global(_method_holder);
-  _method_holder = JNIHandles::make_global(method_holder);
-  return this;
-}
-
-void CompileTask::mark_on_stack() {
-  if (is_unloaded()) {
-    return;
+  if (_method_handle.is_safe()) {
+    _method_handle.make_always_safe();
+    return this;
   }
-  // Mark these methods as something redefine classes cannot remove.
-  _method->set_on_stack(true);
+  return nullptr;
 }
 
 bool CompileTask::is_unloaded() const {
-  return _method_holder != nullptr && JNIHandles::is_weak_global_handle(_method_holder) && JNIHandles::is_weak_global_cleared(_method_holder);
+  return !_method_handle.is_safe();
 }
 
+// ------------------------------------------------------------------
 // RedefineClasses support
+
+void CompileTask::mark_on_stack() {
+  // Mark these methods as something redefine classes cannot remove.
+  // Redefinition runs in VM thread, which cannot ask about the method
+  // safety. This is why we end up asking for method unsafely.
+  assert_at_safepoint();
+  assert(Thread::current()->is_VM_thread(), "Sanity");
+  _method_handle.method_unsafe()->set_on_stack(true);
+}
+
 void CompileTask::metadata_do(MetadataClosure* f) {
-  if (is_unloaded()) {
-    return;
-  }
-  f->do_metadata(method());
+  // Redefinition runs in VM thread, which cannot ask about the method
+  // safety. This is why we end up asking for method unsafely.
+  assert_at_safepoint();
+  assert(Thread::current()->is_VM_thread(), "Sanity");
+  f->do_metadata(_method_handle.method_unsafe());
 }
 
 // ------------------------------------------------------------------

src/hotspot/share/compiler/compileTask.hpp

@@ -29,6 +29,7 @@
 #include "code/nmethod.hpp"
 #include "compiler/compileLog.hpp"
 #include "memory/allocation.hpp"
+#include "oops/unloadableMethodHandle.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "utilities/xmlstream.hpp"
 
@@ -84,8 +85,7 @@ class CompileTask : public CHeapObj<mtCompiler> {
  private:
   static int           _active_tasks;
   int                  _compile_id;
-  Method*              _method;
-  jobject              _method_holder;
+  UnloadableMethodHandle _method_handle;
   int                  _osr_bci;
   bool                 _is_complete;
   bool                 _is_success;
@@ -120,8 +120,9 @@ class CompileTask : public CHeapObj<mtCompiler> {
   ~CompileTask();
   static void wait_for_no_active_tasks();
 
+  inline Method* method() const;
+
   int          compile_id() const                { return _compile_id; }
-  Method*      method() const                    { return _method; }
   int          osr_bci() const                   { return _osr_bci; }
   bool         is_complete() const               { return _is_complete; }
   bool         is_blocking() const               { return _is_blocking; }

src/hotspot/share/compiler/compileTask.inline.hpp

@@ -0,0 +1,36 @@
+/*
+ * Copyright Amazon.com Inc. 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.
+ *
+ */
+
+#ifndef SHARE_COMPILER_COMPILETASK_INLINE_HPP
+#define SHARE_COMPILER_COMPILETASK_INLINE_HPP
+
+#include "compiler/compileTask.hpp"
+
+#include "oops/unloadableMethodHandle.inline.hpp"
+
+inline Method* CompileTask::method() const {
+  return _method_handle.method();
+}
+
+#endif // SHARE_COMPILER_COMPILETASK_INLINE_HPP

src/hotspot/share/jvmci/jvmciEnv.cpp

@@ -27,7 +27,7 @@
 #include "classfile/systemDictionary.hpp"
 #include "code/codeCache.hpp"
 #include "compiler/compilerOracle.hpp"
-#include "compiler/compileTask.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "gc/shared/barrierSet.hpp"
 #include "gc/shared/barrierSetNMethod.hpp"
 #include "jvm_io.h"

src/hotspot/share/oops/trainingData.cpp

@@ -31,7 +31,7 @@
 #include "classfile/javaClasses.hpp"
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionaryShared.hpp"
-#include "compiler/compileTask.hpp"
+#include "compiler/compileTask.inline.hpp"
 #include "memory/metadataFactory.hpp"
 #include "memory/metaspaceClosure.hpp"
 #include "memory/resourceArea.hpp"

src/hotspot/share/oops/unloadableMethodHandle.hpp

@@ -0,0 +1,102 @@
+/*
+ * Copyright Amazon.com Inc. 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.
+ *
+ */
+
+#ifndef SHARE_OOPS_UNLOADABLE_METHOD_HANDLE_HPP
+#define SHARE_OOPS_UNLOADABLE_METHOD_HANDLE_HPP
+
+#include "memory/padded.hpp"
+#include "oops/oopHandle.hpp"
+#include "oops/weakHandle.hpp"
+
+// Unloadable method handle.
+//
+// This handle allows holding to Method* safely without delaying class unloading
+// of its holder.
+//
+// This handle can be in 2 states:
+//  1. Unsafe (weak). Method* is present, but its holder is only weakly-reachable, and can
+//     be unloaded. Users need to check is_safe() before calling method().
+//     method() is safe to call iff we have not crossed a safepoint since construction
+//     or last is_safe() check. Calling make_always_safe() after is_safe() check
+//     moves handle to the strong state.
+//  2. Safe (strong). Method* holder is strongly reachable, cannot be unloaded.
+//     Calling method() is always safe in this state.
+//
+// The handle transitions are one-shot:
+//    unsafe (weak) --(make_always_safe) --> safe (strong)
+//
+// There are internal shortcuts that bypass this mechanics when handle knows
+// the method holder is permanent and would not be unloaded. This is an implementation
+// detail, it does not change any external contract. Using this handle for permanent
+// method holders provides future safety.
+//
+// Common usage pattern:
+//
+//   UnloadableMethodHandle mh(method);   // Now in unsafe (weak) state.
+//   mh.method()->print_on(tty);          // method() is good until the next safepoint.
+//   <safepoint>
+//   if (!mh.is_safe()) {                 // Safe to use method()?
+//     return;                            // Nope!
+//   }
+//   mh.method()->print_on(tty);          // method() is good until the next safepoint.
+//   mh.make_always_safe();               // Now in safe (strong) state.
+//   <safepoint>
+//   mh.method()->print_on(tty);          // method() is always safe now.
+//
+
+class Method;
+
+class UnloadableMethodHandle {
+  friend class VMStructs;
+private:
+  enum class State {
+    PERMANENT,
+    WEAK,
+    STRONG,
+    RELEASED,
+  };
+
+  State volatile _state;
+
+  Method* _method;
+  WeakHandle _weak_handle;
+  OopHandle _strong_handle;
+
+  inline State get_state() const;
+  inline void set_state(State to);
+  inline bool transit_state(State from, State to);
+  inline oop get_unload_blocker(Method* method);
+
+public:
+  UnloadableMethodHandle(Method* method);
+  ~UnloadableMethodHandle();
+
+  inline Method* method() const;
+  inline Method* method_unsafe() const;
+
+  inline bool is_safe() const;
+  void make_always_safe();
+};
+
+#endif // SHARE_OOPS_UNLOADABLE_METHOD_HANDLE_HPP