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

equal deleted inserted replaced

-:a8dcacf95bff
+:1126f0607c70
 // safepoint requests from the VMThread
 // temporarily drops SR_lock while doing wait with safepoint check
 // (if we're a JavaThread - the WatcherThread can also call this)
 // and increase delay with each retry
-SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
+if (Thread::current()->is_Java_thread()) {
+SR_lock()->wait(i * delay);
+} else {
+SR_lock()->wait_without_safepoint_check(i * delay);
+}
 // check the actual thread state instead of what we saved above
 if (thread_state() != _thread_in_native_trans) {
 // the thread has transitioned to another thread state so
 // try all the checks (except this one) one more time.
 // each retry loop. This allows the caller to make use of any
 // unused bits for their own marking purposes.
 reset_bits = *bits;
 {
-MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
+MutexLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
 delay, bits);
 pending = is_external_suspend();
 }
 // must release SR_lock to allow suspension to complete
 {
 MutexLocker ml(SR_lock());
 // wait with safepoint check (if we're a JavaThread - the WatcherThread
 // can also call this)  and increase delay with each retry
-SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
+if (Thread::current()->is_Java_thread()) {
+SR_lock()->wait(i * delay);
+} else {
+SR_lock()->wait_without_safepoint_check(i * delay);
+}
 is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
 delay, bits);
 // It is possible for the external suspend request to be cancelled
 }
 NonJavaThread::~NonJavaThread() { }
 void NonJavaThread::add_to_the_list() {
-MutexLockerEx ml(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker ml(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
 // Initialize BarrierSet-related data before adding to list.
 BarrierSet::barrier_set()->on_thread_attach(this);
 OrderAccess::release_store(&_next, _the_list._head);
 OrderAccess::release_store(&_the_list._head, this);
 }
 void NonJavaThread::remove_from_the_list() {
 {
-MutexLockerEx ml(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker ml(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
 // Cleanup BarrierSet-related data before removing from list.
 BarrierSet::barrier_set()->on_thread_detach(this);
 NonJavaThread* volatile* p = &_the_list._head;
 for (NonJavaThread* t = *p; t != NULL; p = &t->_next, t = *p) {
 if (t == this) {
 }
 }
 // Wait for any in-progress iterators.  Concurrent synchronize is not
 // allowed, so do it while holding a dedicated lock.  Outside and distinct
 // from NJTList_lock in case an iteration attempts to lock it.
-MutexLockerEx ml(NonJavaThreadsListSync_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker ml(NonJavaThreadsListSync_lock, Mutex::_no_safepoint_check_flag);
 _the_list._protect.synchronize();
 _next = NULL;                 // Safe to drop the link now.
 }
 void NonJavaThread::pre_run() {
 }
 int WatcherThread::sleep() const {
 // The WatcherThread does not participate in the safepoint protocol
 // for the PeriodicTask_lock because it is not a JavaThread.
-MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
 if (_should_terminate) {
 // check for termination before we do any housekeeping or wait
 return 0;  // we did not sleep.
 }
 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
 jlong time_before_loop = os::javaTimeNanos();
 while (true) {
-bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag,
+bool timedout = PeriodicTask_lock->wait_without_safepoint_check(remaining);
-remaining);
 jlong now = os::javaTimeNanos();
 if (remaining == 0) {
 // if we didn't have any tasks we could have waited for a long time
 // consider the time_slept zero and reset time_before_loop
 PeriodicTask::real_time_tick(time_waited);
 }
 // Signal that it is terminated
 {
-MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
 _watcher_thread = NULL;
 Terminator_lock->notify_all();
 }
 }
 MutexLocker mu(Terminator_lock);
 while (watcher_thread() != NULL) {
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
-Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
+Terminator_lock->wait(0, Mutex::_as_suspend_equivalent_flag);
-Mutex::_as_suspend_equivalent_flag);
 }
 }
 void WatcherThread::unpark() {
 assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
 // We have notified the agents that we are exiting, before we go on,
 // we must check for a pending external suspend request and honor it
 // in order to not surprise the thread that made the suspend request.
 while (true) {
 {
-MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
+MutexLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 if (!is_external_suspend()) {
 set_terminated(_thread_exiting);
 ThreadService::current_thread_exiting(this, is_daemon(threadObj()));
 break;
 }
 ThreadsListHandle tlh;
 if (!tlh.includes(this) || threadObj() == NULL || is_exiting()) {
 return;
 }
-{ MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
+{ MutexLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 if (!is_external_suspend()) {
 // a racing resume has cancelled us; bail out now
 return;
 }
 assert(_anchor.walkable() ||
 (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()),
 "must have walkable stack");
-MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
+MutexLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 assert(!this->is_ext_suspended(),
 "a thread trying to self-suspend should not already be suspended");
 if (this->is_suspend_equivalent()) {
 ret++;
 this->set_ext_suspended();
 // _ext_suspended flag is cleared by java_resume()
 while (is_ext_suspended()) {
-this->SR_lock()->wait(Mutex::_no_safepoint_check_flag);
+this->SR_lock()->wait_without_safepoint_check();
 }
 }
 return ret;
 }
 ThreadsListHandle tlh;
 if (!tlh.includes(this) || is_exiting() || !is_external_suspend()) {
 return;
 }
-MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
+MutexLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 clear_external_suspend();
 if (is_ext_suspended()) {
 clear_ext_suspended();
 // Wait until we are the last non-daemon thread to execute
 { MutexLocker nu(Threads_lock);
 while (Threads::number_of_non_daemon_threads() > 1)
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
-Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
+Threads_lock->wait(0, Mutex::_as_suspend_equivalent_flag);
-Mutex::_as_suspend_equivalent_flag);
 }
 EventShutdown e;
 if (e.should_commit()) {
 e.set_reason("No remaining non-daemon Java threads");
 // heap is unparseable if they are caught. Grab the Heap_lock
 // to prevent this. The GC vm_operations will not be able to
 // queue until after the vm thread is dead. After this point,
 // we'll never emerge out of the safepoint before the VM exits.
-MutexLockerEx ml(Heap_lock, Mutex::_no_safepoint_check_flag);
+MutexLocker ml(Heap_lock, Mutex::_no_safepoint_check_flag);
 VMThread::wait_for_vm_thread_exit();
 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint");
 VMThread::destroy();
 }

changeset 54623	1126f0607c70
parent 54495	941db9c0b5b5
child 54631	3a3e4e473622