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

equal deleted inserted replaced

-:75f6a833a444
+:e90b4960bcd6
 set_active_handles(NULL);
 set_free_handle_block(NULL);
 set_last_handle_mark(NULL);
 DEBUG_ONLY(_missed_ic_stub_refill_verifier = NULL);
-// This initial value ==> never claimed.
+// Initial value of zero ==> never claimed.
-_oops_do_parity = 0;
+_threads_do_token = 0;
 _threads_hazard_ptr = NULL;
 _threads_list_ptr = NULL;
 _nested_threads_hazard_ptr_cnt = 0;
 _rcu_counter = 0;
 return os::is_interrupted(thread, clear_interrupted);
 }
 // GC Support
-bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
+bool Thread::claim_par_threads_do(uintx claim_token) {
-int thread_parity = _oops_do_parity;
+uintx token = _threads_do_token;
-if (thread_parity != strong_roots_parity) {
+if (token != claim_token) {
-jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
+uintx res = Atomic::cmpxchg(claim_token, &_threads_do_token, token);
-if (res == thread_parity) {
+if (res == token) {
 return true;
-} else {
+}
-guarantee(res == strong_roots_parity, "Or else what?");
+guarantee(res == claim_token, "invariant");
-return false;
-}
 }
 return false;
 }
 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
 }
 NonJavaThread::~NonJavaThread() { }
 void NonJavaThread::add_to_the_list() {
-MutexLockerEx lock(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
+MutexLockerEx ml(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
-_next = _the_list._head;
+// 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 lock(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
+{
-NonJavaThread* volatile* p = &_the_list._head;
+MutexLockerEx ml(NonJavaThreadsList_lock, Mutex::_no_safepoint_check_flag);
-for (NonJavaThread* t = *p; t != NULL; p = &t->_next, t = *p) {
+// Cleanup BarrierSet-related data before removing from list.
-if (t == this) {
+BarrierSet::barrier_set()->on_thread_detach(this);
-*p = this->_next;
+NonJavaThread* volatile* p = &_the_list._head;
-// Wait for any in-progress iterators.  Concurrent synchronize is
+for (NonJavaThread* t = *p; t != NULL; p = &t->_next, t = *p) {
-// not allowed, so do it while holding the list lock.
+if (t == this) {
-_the_list._protect.synchronize();
+*p = _next;
 break;
 }
 }
+}
+// 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);
+_the_list._protect.synchronize();
+_next = NULL;                 // Safe to drop the link now.
 }
 void NonJavaThread::pre_run() {
-// Initialize BarrierSet-related data before adding to list.
-assert(BarrierSet::barrier_set() != NULL, "invariant");
-BarrierSet::barrier_set()->on_thread_attach(this);
 add_to_the_list();
 // This is slightly odd in that NamedThread is a subclass, but
 // in fact name() is defined in Thread
 assert(this->name() != NULL, "thread name was not set before it was started");
 this->set_native_thread_name(this->name());
 }
 void NonJavaThread::post_run() {
 JFR_ONLY(Jfr::on_thread_exit(this);)
-// Clean up BarrierSet data before removing from list.
-BarrierSet::barrier_set()->on_thread_detach(this);
 remove_from_the_list();
 // Ensure thread-local-storage is cleared before termination.
 Thread::clear_thread_current();
 }
 // Signal that it is terminated
 {
 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
 _watcher_thread = NULL;
-Terminator_lock->notify();
+Terminator_lock->notify_all();
 }
 }
 void WatcherThread::start() {
 assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
 this->cache_global_variables();
 // Thread is now sufficiently initialized to be handled by the safepoint code as being
 // in the VM. Change thread state from _thread_new to _thread_in_vm
-ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
+ThreadStateTransition::transition(this, _thread_new, _thread_in_vm);
+// Before a thread is on the threads list it is always safe, so after leaving the
+// _thread_new we should emit a instruction barrier. The distance to modified code
+// from here is probably far enough, but this is consistent and safe.
+OrderAccess::cross_modify_fence();
 assert(JavaThread::current() == this, "sanity check");
 assert(!Thread::current()->owns_locks(), "sanity check");
 DTRACE_THREAD_PROBE(start, this);
 if (log_is_enabled(Debug, os, thread, timer)) {
 _timer_exit_phase1.stop();
 _timer_exit_phase2.start();
 }
+// Capture daemon status before the thread is marked as terminated.
+bool daemon = is_daemon(threadObj());
 // Notify waiters on thread object. This has to be done after exit() is called
 // on the thread (if the thread is the last thread in a daemon ThreadGroup the
 // group should have the destroyed bit set before waiters are notified).
 ensure_join(this);
 assert(!this->has_pending_exception(), "ensure_join should have cleared");
 if (log_is_enabled(Debug, os, thread, timer)) {
 _timer_exit_phase3.stop();
 _timer_exit_phase4.start();
 }
 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
-Threads::remove(this);
+Threads::remove(this, daemon);
 if (log_is_enabled(Debug, os, thread, timer)) {
 _timer_exit_phase4.stop();
 ResourceMark rm(this);
 log_debug(os, thread, timer)("name='%s'"
 _timer_exit_phase3.milliseconds(),
 _timer_exit_phase4.milliseconds());
 }
 }
-void JavaThread::cleanup_failed_attach_current_thread() {
+void JavaThread::cleanup_failed_attach_current_thread(bool is_daemon) {
 if (active_handles() != NULL) {
 JNIHandleBlock* block = active_handles();
 set_active_handles(NULL);
 JNIHandleBlock::release_block(block);
 }
 tlab().retire();
 }
 BarrierSet::barrier_set()->on_thread_detach(this);
-Threads::remove(this);
+Threads::remove(this, is_daemon);
 this->smr_delete();
 }
 JavaThread* JavaThread::active() {
 Thread* thread = Thread::current();
 "must have handled the async condition, if no exception");
 }
 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) {
 //
-// Check for pending external suspend. Internal suspend requests do
+// Check for pending external suspend.
-// not use handle_special_runtime_exit_condition().
 // If JNIEnv proxies are allowed, don't self-suspend if the target
 // thread is not the current thread. In older versions of jdbx, jdbx
 // threads could call into the VM with another thread's JNIEnv so we
 // can be here operating on behalf of a suspended thread (4432884).
 bool do_self_suspend = is_external_suspend_with_lock();
 if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) {
-//
-// Because thread is external suspended the safepoint code will count
-// thread as at a safepoint. This can be odd because we can be here
-// as _thread_in_Java which would normally transition to _thread_blocked
-// at a safepoint. We would like to mark the thread as _thread_blocked
-// before calling java_suspend_self like all other callers of it but
-// we must then observe proper safepoint protocol. (We can't leave
-// _thread_blocked with a safepoint in progress). However we can be
-// here as _thread_in_native_trans so we can't use a normal transition
-// constructor/destructor pair because they assert on that type of
-// transition. We could do something like:
-//
-// JavaThreadState state = thread_state();
-// set_thread_state(_thread_in_vm);
-// {
-//   ThreadBlockInVM tbivm(this);
-//   java_suspend_self()
-// }
-// set_thread_state(_thread_in_vm_trans);
-// if (safepoint) block;
-// set_thread_state(state);
-//
-// but that is pretty messy. Instead we just go with the way the
-// code has worked before and note that this is the only path to
-// java_suspend_self that doesn't put the thread in _thread_blocked
-// mode.
 frame_anchor()->make_walkable(this);
-java_suspend_self();
+java_suspend_self_with_safepoint_check();
+}
-// We might be here for reasons in addition to the self-suspend request
-// so check for other async requests.
+// We might be here for reasons in addition to the self-suspend request
-}
+// so check for other async requests.
 if (check_asyncs) {
 check_and_handle_async_exceptions();
 }
 JFR_ONLY(SUSPEND_THREAD_CONDITIONAL(this);)
 //       thread. java_suspend_self() is the second stage of cooperative
 //       suspension for external suspend requests and should only be used
 //       to complete an external suspend request.
 //
 int JavaThread::java_suspend_self() {
+assert(thread_state() == _thread_blocked, "wrong state for java_suspend_self()");
 int ret = 0;
 // we are in the process of exiting so don't suspend
 if (is_exiting()) {
 clear_external_suspend();
 // _ext_suspended flag is cleared by java_resume()
 while (is_ext_suspended()) {
 this->SR_lock()->wait(Mutex::_no_safepoint_check_flag);
 }
 }
 return ret;
+}
+// Helper routine to set up the correct thread state before calling java_suspend_self.
+// This is called when regular thread-state transition helpers can't be used because
+// we can be in various states, in particular _thread_in_native_trans.
+// Because this thread is external suspended the safepoint code will count it as at
+// a safepoint, regardless of what its actual current thread-state is. But
+// is_ext_suspend_completed() may be waiting to see a thread transition from
+// _thread_in_native_trans to _thread_blocked. So we set the thread state directly
+// to _thread_blocked. The problem with setting thread state directly is that a
+// safepoint could happen just after java_suspend_self() returns after being resumed,
+// and the VM thread will see the _thread_blocked state. So we must check for a safepoint
+// after restoring the state to make sure we won't leave while a safepoint is in progress.
+// However, not all initial-states are allowed when performing a safepoint check, as we
+// should never be blocking at a safepoint whilst in those states. Of these 'bad' states
+// only _thread_in_native is possible when executing this code (based on our two callers).
+// A thread that is _thread_in_native is already safepoint-safe and so it doesn't matter
+// whether the VMThread sees the _thread_blocked state, or the _thread_in_native state,
+// and so we don't need the explicit safepoint check.
+void JavaThread::java_suspend_self_with_safepoint_check() {
+assert(this == Thread::current(), "invariant");
+JavaThreadState state = thread_state();
+set_thread_state(_thread_blocked);
+java_suspend_self();
+set_thread_state_fence(state);
+// Since we are not using a regular thread-state transition helper here,
+// we must manually emit the instruction barrier after leaving a safe state.
+OrderAccess::cross_modify_fence();
+if (state != _thread_in_native) {
+SafepointMechanism::block_if_requested(this);
+}
 }
 #ifdef ASSERT
 // Verify the JavaThread has not yet been published in the Threads::list, and
 // hence doesn't need protection from concurrent access at this stage.
 // If JNIEnv proxies are allowed, don't self-suspend if the target
 // thread is not the current thread. In older versions of jdbx, jdbx
 // threads could call into the VM with another thread's JNIEnv so we
 // can be here operating on behalf of a suspended thread (4432884).
 if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) {
-JavaThreadState state = thread->thread_state();
+thread->java_suspend_self_with_safepoint_check();
+} else {
-// We mark this thread_blocked state as a suspend-equivalent so
+SafepointMechanism::block_if_requested(curJT);
-// that a caller to is_ext_suspend_completed() won't be confused.
+}
-// The suspend-equivalent state is cleared by java_suspend_self().
-thread->set_suspend_equivalent();
-// If the safepoint code sees the _thread_in_native_trans state, it will
-// wait until the thread changes to other thread state. There is no
-// guarantee on how soon we can obtain the SR_lock and complete the
-// self-suspend request. It would be a bad idea to let safepoint wait for
-// too long. Temporarily change the state to _thread_blocked to
-// let the VM thread know that this thread is ready for GC. The problem
-// of changing thread state is that safepoint could happen just after
-// java_suspend_self() returns after being resumed, and VM thread will
-// see the _thread_blocked state. We must check for safepoint
-// after restoring the state and make sure we won't leave while a safepoint
-// is in progress.
-thread->set_thread_state(_thread_blocked);
-thread->java_suspend_self();
-thread->set_thread_state(state);
-InterfaceSupport::serialize_thread_state_with_handler(thread);
-}
-SafepointMechanism::block_if_requested(curJT);
 if (thread->is_deopt_suspend()) {
 thread->clear_deopt_suspend();
 RegisterMap map(thread, false);
 frame f = thread->last_frame();
 if (jvmti_thread_state() != NULL) {
 jvmti_thread_state()->oops_do(f);
 }
 }
+#ifdef ASSERT
+void JavaThread::verify_states_for_handshake() {
+// This checks that the thread has a correct frame state during a handshake.
+assert((!has_last_Java_frame() && java_call_counter() == 0) ||
+(has_last_Java_frame() && java_call_counter() > 0),
+"unexpected frame info: has_last_frame=%d, java_call_counter=%d",
+has_last_Java_frame(), java_call_counter());
+}
+#endif
 void JavaThread::nmethods_do(CodeBlobClosure* cf) {
 assert((!has_last_Java_frame() && java_call_counter() == 0) ||
-(has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
+(has_last_Java_frame() && java_call_counter() > 0),
+"unexpected frame info: has_last_frame=%d, java_call_counter=%d",
+has_last_Java_frame(), java_call_counter());
 if (has_last_Java_frame()) {
 // Traverse the execution stack
 for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
 fst.current()->nmethods_do(cf);
 }
 }
 }
-void JavaThread::metadata_do(void f(Metadata*)) {
+void JavaThread::metadata_do(MetadataClosure* f) {
 if (has_last_Java_frame()) {
 // Traverse the execution stack to call f() on the methods in the stack
 for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
 fst.current()->metadata_do(f);
 }
 JavaThread* Threads::_thread_list = NULL;
 int         Threads::_number_of_threads = 0;
 int         Threads::_number_of_non_daemon_threads = 0;
 int         Threads::_return_code = 0;
-int         Threads::_thread_claim_parity = 0;
+uintx       Threads::_thread_claim_token = 1; // Never zero.
 size_t      JavaThread::_stack_size_at_create = 0;
 #ifdef ASSERT
 bool        Threads::_vm_complete = false;
 #endif
 java_threads_do(tc);
 non_java_threads_do(tc);
 }
 void Threads::possibly_parallel_threads_do(bool is_par, ThreadClosure* tc) {
-int cp = Threads::thread_claim_parity();
+uintx claim_token = Threads::thread_claim_token();
 ALL_JAVA_THREADS(p) {
-if (p->claim_oops_do(is_par, cp)) {
+if (p->claim_threads_do(is_par, claim_token)) {
 tc->do_thread(p);
 }
 }
 VMThread* vmt = VMThread::vm_thread();
-if (vmt->claim_oops_do(is_par, cp)) {
+if (vmt->claim_threads_do(is_par, claim_token)) {
 tc->do_thread(vmt);
 }
 }
 // The system initialization in the library has three phases.
 Handle thread_group = create_initial_thread_group(CHECK);
 Universe::set_main_thread_group(thread_group());
 initialize_class(vmSymbols::java_lang_Thread(), CHECK);
 oop thread_object = create_initial_thread(thread_group, main_thread, CHECK);
 main_thread->set_threadObj(thread_object);
 // Set thread status to running since main thread has
 // been started and running.
 java_lang_Thread::set_thread_status(thread_object,
 java_lang_Thread::RUNNABLE);
 // The VM creates objects of this class.
 initialize_class(vmSymbols::java_lang_Module(), CHECK);
+#ifdef ASSERT
+InstanceKlass *k = SystemDictionary::UnsafeConstants_klass();
+assert(k->is_not_initialized(), "UnsafeConstants should not already be initialized");
+#endif
+// initialize the hardware-specific constants needed by Unsafe
+initialize_class(vmSymbols::jdk_internal_misc_UnsafeConstants(), CHECK);
+jdk_internal_misc_UnsafeConstants::set_unsafe_constants();
 // The VM preresolves methods to these classes. Make sure that they get initialized
 initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK);
 initialize_class(vmSymbols::java_lang_ref_Finalizer(), CHECK);
 // Possible GC point.
 Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p));
 }
-void Threads::remove(JavaThread* p) {
+void Threads::remove(JavaThread* p, bool is_daemon) {
-// Reclaim the objectmonitors from the omInUseList and omFreeList of the moribund thread.
+// Reclaim the ObjectMonitors from the omInUseList and omFreeList of the moribund thread.
 ObjectSynchronizer::omFlush(p);
 // Extra scope needed for Thread_lock, so we can check
 // that we do not remove thread without safepoint code notice
 { MutexLocker ml(Threads_lock);
 } else {
 _thread_list = p->next();
 }
 _number_of_threads--;
-oop threadObj = p->threadObj();
+if (!is_daemon) {
-bool daemon = true;
-if (!is_daemon(threadObj)) {
 _number_of_non_daemon_threads--;
-daemon = false;
 // Only one thread left, do a notify on the Threads_lock so a thread waiting
 // on destroy_vm will wake up.
 if (number_of_non_daemon_threads() == 1) {
 Threads_lock->notify_all();
 }
 }
-ThreadService::remove_thread(p, daemon);
+ThreadService::remove_thread(p, is_daemon);
 // Make sure that safepoint code disregard this thread. This is needed since
 // the thread might mess around with locks after this point. This can cause it
 // to do callbacks into the safepoint code. However, the safepoint code is not aware
 // of this thread since it is removed from the queue.
 p->oops_do(f, cf);
 }
 VMThread::vm_thread()->oops_do(f, cf);
 }
-void Threads::change_thread_claim_parity() {
+void Threads::change_thread_claim_token() {
-// Set the new claim parity.
+if (++_thread_claim_token == 0) {
-assert(_thread_claim_parity >= 0 && _thread_claim_parity <= 2,
+// On overflow of the token counter, there is a risk of future
-"Not in range.");
+// collisions between a new global token value and a stale token
-_thread_claim_parity++;
+// for a thread, because not all iterations visit all threads.
-if (_thread_claim_parity == 3) _thread_claim_parity = 1;
+// (Though it's pretty much a theoretical concern for non-trivial
-assert(_thread_claim_parity >= 1 && _thread_claim_parity <= 2,
+// token counter sizes.)  To deal with the possibility, reset all
-"Not in range.");
+// the thread tokens to zero on global token overflow.
+struct ResetClaims : public ThreadClosure {
+virtual void do_thread(Thread* t) {
+t->claim_threads_do(false, 0);
+}
+} reset_claims;
+Threads::threads_do(&reset_claims);
+// On overflow, update the global token to non-zero, to
+// avoid the special "never claimed" initial thread value.
+_thread_claim_token = 1;
+}
 }
 #ifdef ASSERT
+void assert_thread_claimed(const char* kind, Thread* t, uintx expected) {
+const uintx token = t->threads_do_token();
+assert(token == expected,
+"%s " PTR_FORMAT " has incorrect value " UINTX_FORMAT " != "
+UINTX_FORMAT, kind, p2i(t), token, expected);
+}
 void Threads::assert_all_threads_claimed() {
 ALL_JAVA_THREADS(p) {
-const int thread_parity = p->oops_do_parity();
+assert_thread_claimed("Thread", p, _thread_claim_token);
-assert((thread_parity == _thread_claim_parity),
+}
-"Thread " PTR_FORMAT " has incorrect parity %d != %d", p2i(p), thread_parity, _thread_claim_parity);
+assert_thread_claimed("VMThread", VMThread::vm_thread(), _thread_claim_token);
-}
-VMThread* vmt = VMThread::vm_thread();
-const int thread_parity = vmt->oops_do_parity();
-assert((thread_parity == _thread_claim_parity),
-"VMThread " PTR_FORMAT " has incorrect parity %d != %d", p2i(vmt), thread_parity, _thread_claim_parity);
 }
 #endif // ASSERT
 class ParallelOopsDoThreadClosure : public ThreadClosure {
 private:
 p->nmethods_do(cf);
 }
 }
 }
-void Threads::metadata_do(void f(Metadata*)) {
+void Threads::metadata_do(MetadataClosure* f) {
 ALL_JAVA_THREADS(p) {
 p->metadata_do(f);
 }
 }
 st->print_cr("Threads with active compile tasks:");
 print_threads_compiling(st, buf, buflen);
 }
-void Threads::print_threads_compiling(outputStream* st, char* buf, int buflen) {
+void Threads::print_threads_compiling(outputStream* st, char* buf, int buflen, bool short_form) {
 ALL_JAVA_THREADS(thread) {
 if (thread->is_Compiler_thread()) {
 CompilerThread* ct = (CompilerThread*) thread;
 // Keep task in local variable for NULL check.
 // though, just returned to a free list.
 CompileTask* task = ct->task();
 if (task != NULL) {
 thread->print_name_on_error(st, buf, buflen);
 st->print("  ");
-task->print(st, NULL, true, true);
+task->print(st, NULL, short_form, true);
 }
 }
 }
 }

branch	stuefe-statistical-history
changeset 57335	e90b4960bcd6
parent 57244	a535e674d50d
parent 54495	941db9c0b5b5