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

equal deleted inserted replaced

-:8f17e084029b
+:a02753d5a0b2
 if (UseBiasedLocking) {
 const int alignment = markOopDesc::biased_lock_alignment;
 size_t aligned_size = size + (alignment - sizeof(intptr_t));
 void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
 : AllocateHeap(aligned_size, flags, CURRENT_PC,
 AllocFailStrategy::RETURN_NULL);
 void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
 "JavaThread alignment code overflowed allocated storage");
 if (TraceBiasedLocking) {
 }
 #ifdef ASSERT
 // Private method to check for dangling thread pointer
 void check_for_dangling_thread_pointer(Thread *thread) {
 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
 "possibility of dangling Thread pointer");
 }
 #endif
 if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {
 MutexLocker ml(Threads_lock);  // needed for get_thread_name()
 ResourceMark rm;
 tty->print_cr(
 "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",
 jt->get_thread_name(), *bits);
 guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");
 }
 }
 }
 //
 // Wait for an external suspend request to complete (or be cancelled).
 // Returns true if the thread is externally suspended and false otherwise.
 //
 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay,
 uint32_t *bits) {
 TraceSuspendDebugBits tsdb(this, true /* is_wait */,
 false /* !called_by_wait */, bits);
 // local flag copies to minimize SR_lock hold time
 bool is_suspended;
 // The assertion for that is currently too complex to put here:
 bool JavaThread::profile_last_Java_frame(frame* _fr) {
 bool gotframe = false;
 // self suspension saves needed state.
 if (has_last_Java_frame() && _anchor.walkable()) {
 *_fr = pd_last_frame();
 gotframe = true;
 }
 return gotframe;
 }
 void Thread::interrupt(Thread* thread) {
 if (res == thread_parity) {
 return true;
 } else {
 guarantee(res == strong_roots_parity, "Or else what?");
 assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 return false;
 }
 }
 assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 // The flag: potential_vm_operation notifies if this particular safepoint state could potential
 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
 // no threads which allow_vm_block's are held
 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
 // Check if current thread is allowed to block at a safepoint
 if (!(_allow_safepoint_count == 0))
 fatal("Possible safepoint reached by thread that does not allow it");
 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
 fatal("LEAF method calling lock?");
 }
 #ifdef ASSERT
 if (potential_vm_operation && is_Java_thread()
 && !Universe::is_bootstrapping()) {
 // Make sure we do not hold any locks that the VM thread also uses.
 // This could potentially lead to deadlocks
 for (Monitor *cur = _owned_locks; cur; cur = cur->next()) {
 // Threads_lock is special, since the safepoint synchronization will not start before this is
 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
 // since it is used to transfer control between JavaThreads and the VMThread
 // Do not *exclude* any locks unless you are absolutely sure it is correct. Ask someone else first!
 if ((cur->allow_vm_block() &&
 cur != Threads_lock &&
 cur != Compile_lock &&               // Temporary: should not be necessary when we get separate compilation
 cur != VMOperationRequest_lock &&
 cur != VMOperationQueue_lock) ||
 cur->rank() == Mutex::special) {
 fatal(err_msg("Thread holding lock at safepoint that vm can block on: %s", cur->name()));
-}
 }
 }
+}
-if (GCALotAtAllSafepoints) {
-// We could enter a safepoint here and thus have a gc
+if (GCALotAtAllSafepoints) {
-InterfaceSupport::check_gc_alot();
+// We could enter a safepoint here and thus have a gc
-}
+InterfaceSupport::check_gc_alot();
+}
 #endif
 }
 #endif
 bool Thread::is_in_stack(address adr) const {
 bool Thread::is_lock_owned(address adr) const {
 return on_local_stack(adr);
 }
 bool Thread::set_as_starting_thread() {
 // NOTE: this must be called inside the main thread.
 return os::create_main_thread((JavaThread*)this);
 }
 static void initialize_class(Symbol* class_name, TRAPS) {
 Klass* klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
 Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
 JavaValue result(T_VOID);
 JavaCalls::call_special(&result, thread_oop,
 klass,
 vmSymbols::object_initializer_name(),
 vmSymbols::threadgroup_string_void_signature(),
 thread_group,
 string,
 CHECK_NULL);
 return thread_oop();
 }
 static void call_initializeSystemClass(TRAPS) {
 Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::initializeSystemClass_name(),
 vmSymbols::void_method_signature(), CHECK);
 }
 char java_runtime_name[128] = "";
 char java_runtime_version[128] = "";
 // extract the JRE name from sun.misc.Version.java_runtime_name
 static const char* get_java_runtime_name(TRAPS) {
 Klass* k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
 Handle(), Handle(), CHECK_AND_CLEAR_NULL);
 fieldDescriptor fd;
 bool found = k != NULL &&
 InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_name_name(),
 vmSymbols::string_signature(), &fd);
 if (found) {
 }
 // extract the JRE version from sun.misc.Version.java_runtime_version
 static const char* get_java_runtime_version(TRAPS) {
 Klass* k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
 Handle(), Handle(), CHECK_AND_CLEAR_NULL);
 fieldDescriptor fd;
 bool found = k != NULL &&
 InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_version_name(),
 vmSymbols::string_signature(), &fd);
 if (found) {
 Klass* k = SystemDictionary::resolve_or_null(vmSymbols::sun_misc_PostVMInitHook(), THREAD);
 instanceKlassHandle klass (THREAD, k);
 if (klass.not_null()) {
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(),
 vmSymbols::void_method_signature(),
 CHECK);
 }
 }
 static void reset_vm_info_property(TRAPS) {
 // the vm info string
 THREAD);
 }
 if (daemon) {
 java_lang_Thread::set_daemon(thread_oop());
 }
 if (HAS_PENDING_EXCEPTION) {
 return;
 }
 KlassHandle group(this, SystemDictionary::ThreadGroup_klass());
 Handle threadObj(this, this->threadObj());
 JavaCalls::call_special(&result,
 thread_group,
 group,
 vmSymbols::add_method_name(),
 vmSymbols::thread_void_signature(),
 threadObj,          // Arg 1
 THREAD);
 }
 // NamedThread --  non-JavaThread subclasses with multiple
 for (;;) {
 bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag, 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
 time_slept = 0;
 time_before_loop = now;
 } else {
 // need to recalculate since we might have new tasks in _tasks
 time_slept = (int) ((now - time_before_loop) / 1000000);
 }
 // Change to task list or spurious wakeup of some kind
 if (timedout || _should_terminate) {
 break;
 }
 remaining = PeriodicTask::time_to_wait();
 if (remaining == 0) {
 // Last task was just disenrolled so loop around and wait until
 // another task gets enrolled
 continue;
 }
 remaining -= time_slept;
 if (remaining <= 0)
 break;
 // also because the WatcherThread is less likely to crash than other
 // threads.
 for (;;) {
 if (!ShowMessageBoxOnError
 && (OnError == NULL || OnError[0] == '\0')
 && Arguments::abort_hook() == NULL) {
 os::sleep(this, 2 * 60 * 1000, false);
 fdStream err(defaultStream::output_fd());
 err.print_raw_cr("# [ timer expired, abort... ]");
 // skip atexit/vm_exit/vm_abort hooks
 os::die();
 }
 // Wake up 5 seconds later, the fatal handler may reset OnError or
 // ShowMessageBoxOnError when it is ready to abort.
 os::sleep(this, 5 * 1000, false);
 SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
 DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
 #endif // INCLUDE_ALL_GCS
 JavaThread::JavaThread(bool is_attaching_via_jni) :
 Thread()
 #if INCLUDE_ALL_GCS
 , _satb_mark_queue(&_satb_mark_queue_set),
 _dirty_card_queue(&_dirty_card_queue_set)
 #endif // INCLUDE_ALL_GCS
 {
 initialize();
 if (is_attaching_via_jni) {
 _jni_attach_state = _attaching_via_jni;
 // Remove this ifdef when C1 is ported to the compiler interface.
 static void compiler_thread_entry(JavaThread* thread, TRAPS);
 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
 Thread()
 #if INCLUDE_ALL_GCS
 , _satb_mark_queue(&_satb_mark_queue_set),
 _dirty_card_queue(&_dirty_card_queue_set)
 #endif // INCLUDE_ALL_GCS
 {
 if (TraceThreadEvents) {
 tty->print_cr("creating thread %p", this);
 }
 // object must be fully initialized (take a look at JVM_Start)
 }
 JavaThread::~JavaThread() {
 if (TraceThreadEvents) {
 tty->print_cr("terminate thread %p", this);
 }
 // JSR166 -- return the parker to the free list
 Parker::Release(_parker);
 _parker = NULL;
 JvmtiExport::post_thread_start(this);
 }
 EventThreadStart event;
 if (event.should_commit()) {
 event.set_javalangthread(java_lang_Thread::thread_id(this->threadObj()));
 event.commit();
 }
 // We call another function to do the rest so we are sure that the stack addresses used
 // from there will be lower than the stack base just computed
 thread_main_inner();
 uncaught_exception,
 THREAD);
 if (HAS_PENDING_EXCEPTION) {
 ResourceMark rm(this);
 jio_fprintf(defaultStream::error_stream(),
 "\nException: %s thrown from the UncaughtExceptionHandler"
 " in thread \"%s\"\n",
 pending_exception()->klass()->external_name(),
 get_thread_name());
 CLEAR_PENDING_EXCEPTION;
 }
 }
 // Called before the java thread exit since we want to read info
 // from java_lang_Thread object
 EventThreadEnd event;
 if (event.should_commit()) {
 event.set_javalangthread(java_lang_Thread::thread_id(this->threadObj()));
 event.commit();
 }
 // Call after last event on thread
 EVENT_THREAD_EXIT(this);
 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
 EXCEPTION_MARK;
 JavaValue result(T_VOID);
 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
 JavaCalls::call_virtual(&result,
 threadObj, thread_klass,
 vmSymbols::exit_method_name(),
 vmSymbols::void_method_signature(),
 THREAD);
 CLEAR_PENDING_EXCEPTION;
 }
 }
 // notify JVMTI
 if (JvmtiExport::should_post_thread_life()) {
 if (check_unsafe_error &&
 condition == _async_unsafe_access_error && !has_pending_exception()) {
 condition = _no_async_condition;  // done
 switch (thread_state()) {
 case _thread_in_vm:
 {
 JavaThread* THREAD = this;
 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
 }
 case _thread_in_native:
 {
 ThreadInVMfromNative tiv(this);
 JavaThread* THREAD = this;
 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
 }
 case _thread_in_Java:
 {
 ThreadInVMfromJava tiv(this);
 JavaThread* THREAD = this;
 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code");
 }
 default:
 ShouldNotReachHere();
 }
 }
 // Set async. pending exception in thread.
 set_pending_async_exception(java_throwable);
 if (TraceExceptions) {
 ResourceMark rm;
 tty->print_cr("Pending Async. exception installed of type: %s", InstanceKlass::cast(_pending_async_exception->klass())->external_name());
 }
 // for AbortVMOnException flag
 NOT_PRODUCT(Exceptions::debug_check_abort(InstanceKlass::cast(_pending_async_exception->klass())->external_name()));
 }
 }
 //   + Target thread will not enter any new monitors
 //
 void JavaThread::java_suspend() {
 { MutexLocker mu(Threads_lock);
 if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) {
 return;
 }
 }
 { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 if (!is_external_suspend()) {
 int JavaThread::java_suspend_self() {
 int ret = 0;
 // we are in the process of exiting so don't suspend
 if (is_exiting()) {
 clear_external_suspend();
 return ret;
 }
 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);
 assert(!this->is_ext_suspended(),
 "a thread trying to self-suspend should not already be suspended");
 if (this->is_suspend_equivalent()) {
 // If we are self-suspending as a result of the lifting of a
 // suspend equivalent condition, then the suspend_equivalent
 // flag is not cleared until we set the ext_suspended flag so
 #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
 void JavaThread::verify_not_published() {
 if (!Threads_lock->owned_by_self()) {
 MutexLockerEx ml(Threads_lock,  Mutex::_no_safepoint_check_flag);
 assert(!Threads::includes(this),
 "java thread shouldn't have been published yet!");
 }
 else {
 assert(!Threads::includes(this),
 "java thread shouldn't have been published yet!");
 }
 }
 #endif
 } else {
 if (_stack_guard_state == stack_guard_unused) return;
 if (os::unguard_memory((char *) low_addr, len)) {
 _stack_guard_state = stack_guard_unused;
 } else {
 warning("Attempt to unprotect stack guard pages failed.");
 }
 }
 }
 void JavaThread::enable_stack_yellow_zone() {
 // If the caller is a NamedThread, then remember, in the current scope,
 // the given JavaThread in its _processed_thread field.
 class RememberProcessedThread: public StackObj {
 NamedThread* _cur_thr;
 public:
 RememberProcessedThread(JavaThread* jthr) {
 Thread* thread = Thread::current();
 if (thread->is_Named_thread()) {
 _cur_thr = (NamedThread *)thread;
 _cur_thr->set_processed_thread(jthr);
 // Traverse the GCHandles
 Thread::oops_do(f, cld_f, cf);
 assert((!has_last_Java_frame() && java_call_counter() == 0) ||
 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
 if (has_last_Java_frame()) {
 // Record JavaThread to GC thread
 RememberProcessedThread rpt(this);
 void JavaThread::nmethods_do(CodeBlobClosure* cf) {
 Thread::nmethods_do(cf);  // (super method is a no-op)
 assert((!has_last_Java_frame() && java_call_counter() == 0) ||
 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
 if (has_last_Java_frame()) {
 // Traverse the execution stack
 for (StackFrameStream fst(this); !fst.is_done(); fst.next()) {
 fst.current()->nmethods_do(cf);
 // JavaThread::print() is that we can't grab lock or allocate memory.
 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const {
 st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen));
 oop thread_obj = threadObj();
 if (thread_obj != NULL) {
 if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon");
 }
 st->print(" [");
 st->print("%s", _get_thread_state_name(_thread_state));
 if (osthread()) {
 st->print(", id=%d", osthread()->thread_id());
 // the Threads_lock.
 assert_locked_or_safepoint(Threads_lock);
 }
 }
 #endif // ASSERT
 return get_thread_name_string();
 }
 // Returns a non-NULL representation of this thread's name, or a suitable
 // descriptive string if there is no set name
 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const {
 // oop representing the java_lang_Thread to the new thread (a JavaThread *).
 Handle thread_oop(Thread::current(),
 JNIHandles::resolve_non_null(jni_thread));
 assert(InstanceKlass::cast(thread_oop->klass())->is_linked(),
 "must be initialized");
 set_threadObj(thread_oop());
 java_lang_Thread::set_thread(thread_oop(), this);
 if (prio == NoPriority) {
 prio = java_lang_Thread::priority(thread_oop());
 main_thread->set_active_handles(JNIHandleBlock::allocate_block());
 if (!main_thread->set_as_starting_thread()) {
 vm_shutdown_during_initialization(
 "Failed necessary internal allocation. Out of swap space");
 delete main_thread;
 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
 return JNI_ENOMEM;
 }
 CLEAR_PENDING_EXCEPTION;
 }
 }
 {
 MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
 // Make sure the watcher thread can be started by WatcherThread::start()
 // or by dynamic enrollment.
 WatcherThread::make_startable();
 // Start up the WatcherThread if there are any periodic tasks
 // NOTE:  All PeriodicTasks should be registered by now. If they
 //   aren't, late joiners might appear to start slowly (we might
 //   take a while to process their first tick).
 if (PeriodicTask::num_tasks() > 0) {
 WatcherThread::start();
 }
 }
 // Give os specific code one last chance to start
 os::init_3();
 extern struct JavaVM_ main_vm;
 for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
 // Find the Agent_OnUnload function.
 Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t,
 os::find_agent_function(agent,
 false,
 on_unload_symbols,
 num_symbol_entries));
 // Invoke the Agent_OnUnload function
 if (unload_entry != NULL) {
 JavaThread* thread = JavaThread::current();
 ThreadToNativeFromVM ttn(thread);
 // turn off parallelism in process_roots while active_workers
 // is being used for parallelism elsewhere.
 bool is_par = sh->n_par_threads() > 0;
 assert(!is_par ||
 (SharedHeap::heap()->n_par_threads() ==
 SharedHeap::heap()->workers()->active_workers()), "Mismatch");
 int cp = SharedHeap::heap()->strong_roots_parity();
 ALL_JAVA_THREADS(p) {
 if (p->claim_oops_do(is_par, cp)) {
 p->oops_do(f, cld_f, cf);
 }
 }
 // Get count Java threads that are waiting to enter the specified monitor.
 GrowableArray<JavaThread*>* Threads::get_pending_threads(int count,
 address monitor, bool doLock) {
 assert(doLock || SafepointSynchronize::is_at_safepoint(),
 "must grab Threads_lock or be at safepoint");
 GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count);
 int i = 0;
 {
 MutexLockerEx ml(doLock ? Threads_lock : NULL);
 void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) {
 char buf[32];
 st->print_cr("%s", os::local_time_string(buf, sizeof(buf)));
 st->print_cr("Full thread dump %s (%s %s):",
 Abstract_VM_Version::vm_name(),
 Abstract_VM_Version::vm_release(),
 Abstract_VM_Version::vm_info_string()
 );
 st->cr();
 #if INCLUDE_ALL_GCS
 // Dump concurrent locks
 ConcurrentLocksDump concurrent_locks;
 typedef volatile int SpinLockT;
 void Thread::SpinAcquire (volatile int * adr, const char * LockName) {
 if (Atomic::cmpxchg (1, adr, 0) == 0) {
 return;   // normal fast-path return
 }
 // Slow-path : We've encountered contention -- Spin/Yield/Block strategy.
 TEVENT(SpinAcquire - ctx);
 int ctr = 0;
 int Yields = 0;
 for (;;) {
 while (*adr != 0) {
 ++ctr;
 if ((ctr & 0xFFF) == 0 || !os::is_MP()) {
 if (Yields > 5) {
 os::naked_short_sleep(1);
-} else {
-os::naked_yield();
-++Yields;
-}
 } else {
-SpinPause();
+os::naked_yield();
+++Yields;
 }
-}
+} else {
-if (Atomic::cmpxchg(1, adr, 0) == 0) return;
+SpinPause();
+}
+}
+if (Atomic::cmpxchg(1, adr, 0) == 0) return;
 }
 }
 void Thread::SpinRelease (volatile int * adr) {
 assert(*adr != 0, "invariant");
 void Thread::muxAcquire (volatile intptr_t * Lock, const char * LockName) {
 intptr_t w = Atomic::cmpxchg_ptr(LOCKBIT, Lock, 0);
 if (w == 0) return;
 if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
 return;
 }
 TEVENT(muxAcquire - Contention);
 ParkEvent * const Self = Thread::current()->_MuxEvent;
 assert((intptr_t(Self) & LOCKBIT) == 0, "invariant");
 for (;;) {
 int its = (os::is_MP() ? 100 : 0) + 1;
 // Optional spin phase: spin-then-park strategy
 while (--its >= 0) {
 w = *Lock;
 if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
+return;
+}
+}
+Self->reset();
+Self->OnList = intptr_t(Lock);
+// The following fence() isn't _strictly necessary as the subsequent
+// CAS() both serializes execution and ratifies the fetched *Lock value.
+OrderAccess::fence();
+for (;;) {
+w = *Lock;
+if ((w & LOCKBIT) == 0) {
+if (Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
+Self->OnList = 0;   // hygiene - allows stronger asserts
 return;
-}
-}
-Self->reset();
-Self->OnList = intptr_t(Lock);
-// The following fence() isn't _strictly necessary as the subsequent
-// CAS() both serializes execution and ratifies the fetched *Lock value.
-OrderAccess::fence();
-for (;;) {
-w = *Lock;
-if ((w & LOCKBIT) == 0) {
-if (Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
-Self->OnList = 0;   // hygiene - allows stronger asserts
-return;
-}
-continue;      // Interference -- *Lock changed -- Just retry
 }
-assert(w & LOCKBIT, "invariant");
+continue;      // Interference -- *Lock changed -- Just retry
-Self->ListNext = (ParkEvent *) (w & ~LOCKBIT);
+}
-if (Atomic::cmpxchg_ptr(intptr_t(Self)|LOCKBIT, Lock, w) == w) break;
+assert(w & LOCKBIT, "invariant");
-}
+Self->ListNext = (ParkEvent *) (w & ~LOCKBIT);
+if (Atomic::cmpxchg_ptr(intptr_t(Self)|LOCKBIT, Lock, w) == w) break;
-while (Self->OnList != 0) {
+}
-Self->park();
-}
+while (Self->OnList != 0) {
+Self->park();
+}
 }
 }
 void Thread::muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) {
 intptr_t w = Atomic::cmpxchg_ptr(LOCKBIT, Lock, 0);

changeset 26683	a02753d5a0b2
parent 25946	1572c9f03fb9
child 26684	d1221849ea3d