8357481: Excessive CompileTask wait/notify monitor creation

Reviewed-by: vlivanov, kvn

Author: shipilev

src/hotspot/share/compiler/compileBroker.cpp

@@ -231,7 +231,7 @@ CompileTaskWrapper::~CompileTaskWrapper() {
   if (task->is_blocking()) {
     bool free_task = false;
     {
-      MutexLocker notifier(thread, task->lock());
+      MutexLocker notifier(thread, CompileTaskWait_lock);
       task->mark_complete();
 #if INCLUDE_JVMCI
       if (CompileBroker::compiler(task->comp_level())->is_jvmci()) {
@@ -245,7 +245,7 @@ CompileTaskWrapper::~CompileTaskWrapper() {
       if (!free_task) {
         // Notify the waiting thread that the compilation has completed
         // so that it can free the task.
-        task->lock()->notify_all();
+        CompileTaskWait_lock->notify_all();
       }
     }
     if (free_task) {
@@ -375,12 +375,12 @@ void CompileQueue::free_all() {
     next = current->next();
     bool found_waiter = false;
     {
-      MutexLocker ct_lock(current->lock());
+      MutexLocker ct_lock(CompileTaskWait_lock);
       assert(current->waiting_for_completion_count() <= 1, "more than one thread are waiting for task");
       if (current->waiting_for_completion_count() > 0) {
         // If another thread waits for this task, we must wake them up
         // so they will stop waiting and free the task.
-        current->lock()->notify();
+        CompileTaskWait_lock->notify_all();
         found_waiter = true;
       }
     }
@@ -1655,7 +1655,7 @@ static const int JVMCI_COMPILATION_PROGRESS_WAIT_ATTEMPTS = 10;
  */
 bool CompileBroker::wait_for_jvmci_completion(JVMCICompiler* jvmci, CompileTask* task, JavaThread* thread) {
   assert(UseJVMCICompiler, "sanity");
-  MonitorLocker ml(thread, task->lock());
+  MonitorLocker ml(thread, CompileTaskWait_lock);
   int progress_wait_attempts = 0;
   jint thread_jvmci_compilation_ticks = 0;
   jint global_jvmci_compilation_ticks = jvmci->global_compilation_ticks();
@@ -1723,7 +1723,7 @@ void CompileBroker::wait_for_completion(CompileTask* task) {
   } else
 #endif
   {
-    MonitorLocker ml(thread, task->lock());
+    MonitorLocker ml(thread, CompileTaskWait_lock);
     free_task = true;
     task->inc_waiting_for_completion();
     while (!task->is_complete() && !is_compilation_disabled_forever()) {

src/hotspot/share/compiler/compileTask.cpp

@@ -65,7 +65,6 @@ CompileTask* CompileTask::allocate() {
 void CompileTask::free(CompileTask* task) {
   MutexLocker locker(CompileTaskAlloc_lock);
   if (!task->is_free()) {
-    assert(!task->lock()->is_locked(), "Should not be locked when freed");
     if ((task->_method_holder != nullptr && JNIHandles::is_weak_global_handle(task->_method_holder))) {
       JNIHandles::destroy_weak_global(task->_method_holder);
     } else {
@@ -90,8 +89,6 @@ void CompileTask::initialize(int compile_id,
                              int hot_count,
                              CompileTask::CompileReason compile_reason,
                              bool is_blocking) {
-  assert(!_lock->is_locked(), "bad locking");
-
   Thread* thread = Thread::current();
   _compile_id = compile_id;
   _method = method();

src/hotspot/share/compiler/compileTask.hpp

@@ -29,6 +29,7 @@
 #include "code/nmethod.hpp"
 #include "compiler/compileLog.hpp"
 #include "memory/allocation.hpp"
+#include "runtime/mutexLocker.hpp"
 #include "utilities/xmlstream.hpp"
 
 class CompileTrainingData;
@@ -82,7 +83,6 @@ class CompileTask : public CHeapObj<mtCompiler> {
 
  private:
   static CompileTask*  _task_free_list;
-  Monitor*             _lock;
   int                  _compile_id;
   Method*              _method;
   jobject              _method_holder;
@@ -116,11 +116,7 @@ class CompileTask : public CHeapObj<mtCompiler> {
   size_t               _arena_bytes;  // peak size of temporary memory during compilation (e.g. node arenas)
 
  public:
-  CompileTask() : _failure_reason(nullptr), _failure_reason_on_C_heap(false) {
-    // May hold MethodCompileQueue_lock
-    _lock = new Monitor(Mutex::safepoint-1, "CompileTask_lock");
-  }
-
+  CompileTask() : _failure_reason(nullptr), _failure_reason_on_C_heap(false) {}
   void initialize(int compile_id, const methodHandle& method, int osr_bci, int comp_level,
                   int hot_count,
                   CompileTask::CompileReason compile_reason, bool is_blocking);
@@ -172,21 +168,19 @@ class CompileTask : public CHeapObj<mtCompiler> {
   }
 #endif
 
-  Monitor*     lock() const                      { return _lock; }
-
   // See how many threads are waiting for this task. Must have lock to read this.
   int waiting_for_completion_count() {
-    assert(_lock->owned_by_self(), "must have lock to use waiting_for_completion_count()");
+    assert(CompileTaskWait_lock->owned_by_self(), "must have lock to use waiting_for_completion_count()");
     return _waiting_count;
   }
   // Indicates that a thread is waiting for this task to complete. Must have lock to use this.
   void inc_waiting_for_completion() {
-    assert(_lock->owned_by_self(), "must have lock to use inc_waiting_for_completion()");
+    assert(CompileTaskWait_lock->owned_by_self(), "must have lock to use inc_waiting_for_completion()");
     _waiting_count++;
   }
   // Indicates that a thread stopped waiting for this task to complete. Must have lock to use this.
   void dec_waiting_for_completion() {
-    assert(_lock->owned_by_self(), "must have lock to use dec_waiting_for_completion()");
+    assert(CompileTaskWait_lock->owned_by_self(), "must have lock to use dec_waiting_for_completion()");
     assert(_waiting_count > 0, "waiting count is not positive");
     _waiting_count--;
   }

src/hotspot/share/runtime/mutexLocker.cpp

@@ -79,6 +79,7 @@ Mutex*   MarkStackChunkList_lock      = nullptr;
 Mutex*   MonitoringSupport_lock       = nullptr;
 Monitor* ConcurrentGCBreakpoints_lock = nullptr;
 Mutex*   Compile_lock                 = nullptr;
+Monitor* CompileTaskWait_lock         = nullptr;
 Monitor* MethodCompileQueue_lock      = nullptr;
 Monitor* CompileThread_lock           = nullptr;
 Monitor* Compilation_lock             = nullptr;
@@ -342,7 +343,9 @@ void mutex_init() {
     MUTEX_DEFL(G1RareEvent_lock             , PaddedMutex  , Threads_lock, true);
   }
 
-  MUTEX_DEFL(CompileTaskAlloc_lock          , PaddedMutex  ,  MethodCompileQueue_lock);
+  MUTEX_DEFL(CompileTaskAlloc_lock          , PaddedMutex  , MethodCompileQueue_lock);
+  MUTEX_DEFL(CompileTaskWait_lock           , PaddedMonitor, MethodCompileQueue_lock);
+
 #if INCLUDE_PARALLELGC
   if (UseParallelGC) {
     MUTEX_DEFL(PSOldGenExpand_lock          , PaddedMutex  , Heap_lock, true);

src/hotspot/share/runtime/mutexLocker.hpp

@@ -86,6 +86,7 @@ extern Monitor* Compilation_lock;                // a lock used to pause compila
 extern Mutex*   TrainingData_lock;               // a lock used when accessing training records
 extern Monitor* TrainingReplayQueue_lock;        // a lock held when class are added/removed to the training replay queue
 extern Mutex*   CompileTaskAlloc_lock;           // a lock held when CompileTasks are allocated
+extern Monitor* CompileTaskWait_lock;            // a lock held when CompileTasks are waited/notified
 extern Mutex*   CompileStatistics_lock;          // a lock held when updating compilation statistics
 extern Mutex*   DirectivesStack_lock;            // a lock held when mutating the dirstack and ref counting directives
 extern Monitor* Terminator_lock;                 // a lock used to guard termination of the vm