jdk-sandbox: comparison src/hotspot/share/runtime/vmThread.cpp

equal deleted inserted replaced

-:a8dcacf95bff
+:1126f0607c70
 // VM thread to enter any lock at Safepoint as long as its _owner is NULL.
 // If that happens after _terminate_lock->wait() has unset _owner
 // but before it actually drops the lock and waits, the notification below
 // may get lost and we will have a hang. To avoid this, we need to use
 // Mutex::lock_without_safepoint_check().
-MutexLockerEx ml(_terminate_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker ml(_terminate_lock, Mutex::_no_safepoint_check_flag);
 _terminated = true;
 _terminate_lock->notify();
 }
 // We are now racing with the VM termination being carried out in
 // Notify the VMThread that the last non-daemon JavaThread has terminated,
 // and wait until operation is performed.
 void VMThread::wait_for_vm_thread_exit() {
 assert(Thread::current()->is_Java_thread(), "Should be a JavaThread");
 assert(((JavaThread*)Thread::current())->is_terminated(), "Should be terminated");
-{ MutexLockerEx mu(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
+{ MutexLocker mu(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
 _should_terminate = true;
 VMOperationQueue_lock->notify();
 }
 // Note: VM thread leaves at Safepoint. We are not stopped by Safepoint
 // Wait until VM thread is terminated
 // Note: it should be OK to use Terminator_lock here. But this is called
 // at a very delicate time (VM shutdown) and we are operating in non- VM
 // thread at Safepoint. It's safer to not share lock with other threads.
-{ MutexLockerEx ml(_terminate_lock, Mutex::_no_safepoint_check_flag);
+{ MutexLocker ml(_terminate_lock, Mutex::_no_safepoint_check_flag);
 while(!VMThread::is_terminated()) {
-_terminate_lock->wait(Mutex::_no_safepoint_check_flag);
+_terminate_lock->wait_without_safepoint_check();
 }
 }
 }
 static void post_vm_operation_event(EventExecuteVMOperation* event, VM_Operation* op) {
 VM_Operation* safepoint_ops = NULL;
 //
 // Wait for VM operation
 //
 // use no_safepoint_check to get lock without attempting to "sneak"
-{ MutexLockerEx mu_queue(VMOperationQueue_lock,
+{ MutexLocker mu_queue(VMOperationQueue_lock,
 Mutex::_no_safepoint_check_flag);
 // Look for new operation
 assert(_cur_vm_operation == NULL, "no current one should be executing");
 _cur_vm_operation = _vm_queue->remove_next();
 }
 while (!should_terminate() && _cur_vm_operation == NULL) {
 // wait with a timeout to guarantee safepoints at regular intervals
 bool timedout =
-VMOperationQueue_lock->wait(Mutex::_no_safepoint_check_flag,
+VMOperationQueue_lock->wait_without_safepoint_check(GuaranteedSafepointInterval);
-GuaranteedSafepointInterval);
 // Support for self destruction
 if ((SelfDestructTimer != 0) && !VMError::is_error_reported() &&
 (os::elapsedTime() > (double)SelfDestructTimer * 60.0)) {
 tty->print_cr("VM self-destructed");
 }
 if (timedout) {
 // Have to unlock VMOperationQueue_lock just in case no_op_safepoint()
 // has to do a handshake.
-MutexUnlockerEx mul(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
+MutexUnlocker mul(VMOperationQueue_lock, Mutex::_no_safepoint_check_flag);
 if ((_cur_vm_operation = VMThread::no_op_safepoint()) != NULL) {
 // Force a safepoint since we have not had one for at least
 // 'GuaranteedSafepointInterval' milliseconds and we need to clean
 // something. This will run all the clean-up processing that needs
 // to be done at a safepoint.
 // that simply means the op will wait for the next major cycle of the
 // VMThread - just as it would if the GC thread lost the race for
 // the lock.
 if (_vm_queue->peek_at_safepoint_priority()) {
 // must hold lock while draining queue
-MutexLockerEx mu_queue(VMOperationQueue_lock,
+MutexLocker mu_queue(VMOperationQueue_lock,
 Mutex::_no_safepoint_check_flag);
 safepoint_ops = _vm_queue->drain_at_safepoint_priority();
 } else {
 safepoint_ops = NULL;
 }
 } while(safepoint_ops != NULL);
 }
 //
 //  Notify (potential) waiting Java thread(s) - lock without safepoint
 //  check so that sneaking is not possible
-{ MutexLockerEx mu(VMOperationRequest_lock,
+{ MutexLocker mu(VMOperationRequest_lock,
 Mutex::_no_safepoint_check_flag);
 VMOperationRequest_lock->notify_all();
 }
 // We want to make sure that we get to a safepoint regularly
 // even when executing VMops that don't require safepoints.
 if (!concurrent) {
 // Wait for completion of request (non-concurrent)
 // Note: only a JavaThread triggers the safepoint check when locking
 MutexLocker mu(VMOperationRequest_lock);
 while(t->vm_operation_completed_count() < ticket) {
-VMOperationRequest_lock->wait(!t->is_Java_thread());
+if (t->is_Java_thread()) {
+VMOperationRequest_lock->wait();
+} else {
+VMOperationRequest_lock->wait_without_safepoint_check();
+}
 }
 }
 if (execute_epilog) {
 op->doit_epilogue();

changeset 54623	1126f0607c70
parent 54278	16999bd91ba6
child 54645	05aaccf7d558