truffle: src/os/linux/vm/os_linux.cpp comparison

comparison src/os/linux/vm/os_linux.cpp @ 7643:3ac7d10a6572

Merge with hsx25/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Thu, 31 Jan 2013 15:42:25 +0100
parents	989155e2d07a 22ba8c8ce6a6
children	5fc51c1ecdeb

comparison

equal deleted inserted replaced

-:17b6a63fe7c2
+:3ac7d10a6572
 /*
-* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 if (status == ETIME) { status = EINTR; }
 assert_status(status == 0 || status == EINTR, status, "cond_wait");
 }
 -- _nParked ;
-// In theory we could move the ST of 0 into _Event past the unlock(),
-// but then we'd need a MEMBAR after the ST.
 _Event = 0 ;
 status = pthread_mutex_unlock(_mutex);
 assert_status(status == 0, status, "mutex_unlock");
+// Paranoia to ensure our locked and lock-free paths interact
+// correctly with each other.
+OrderAccess::fence();
 }
 guarantee (_Event >= 0, "invariant") ;
 }
 int os::PlatformEvent::park(jlong millis) {
 }
 _Event = 0 ;
 status = pthread_mutex_unlock(_mutex);
 assert_status(status == 0, status, "mutex_unlock");
 assert (_nParked == 0, "invariant") ;
+// Paranoia to ensure our locked and lock-free paths interact
+// correctly with each other.
+OrderAccess::fence();
 return ret;
 }
 void os::PlatformEvent::unpark() {
-int v, AnyWaiters ;
+// Transitions for _Event:
-for (;;) {
+//    0 :=> 1
-v = _Event ;
+//    1 :=> 1
-if (v > 0) {
+//   -1 :=> either 0 or 1; must signal target thread
-// The LD of _Event could have reordered or be satisfied
+//          That is, we can safely transition _Event from -1 to either
-// by a read-aside from this processor's write buffer.
+//          0 or 1. Forcing 1 is slightly more efficient for back-to-back
-// To avoid problems execute a barrier and then
+//          unpark() calls.
-// ratify the value.
+// See also: "Semaphores in Plan 9" by Mullender & Cox
-OrderAccess::fence() ;
+//
-if (_Event == v) return ;
+// Note: Forcing a transition from "-1" to "1" on an unpark() means
-continue ;
+// that it will take two back-to-back park() calls for the owning
-}
+// thread to block. This has the benefit of forcing a spurious return
-if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
+// from the first park() call after an unpark() call which will help
-}
+// shake out uses of park() and unpark() without condition variables.
-if (v < 0) {
-// Wait for the thread associated with the event to vacate
+if (Atomic::xchg(1, &_Event) >= 0) return;
-int status = pthread_mutex_lock(_mutex);
-assert_status(status == 0, status, "mutex_lock");
+// Wait for the thread associated with the event to vacate
-AnyWaiters = _nParked ;
+int status = pthread_mutex_lock(_mutex);
-assert (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ;
+assert_status(status == 0, status, "mutex_lock");
-if (AnyWaiters != 0 && WorkAroundNPTLTimedWaitHang) {
+int AnyWaiters = _nParked;
-AnyWaiters = 0 ;
+assert(AnyWaiters == 0 || AnyWaiters == 1, "invariant");
-pthread_cond_signal (_cond);
+if (AnyWaiters != 0 && WorkAroundNPTLTimedWaitHang) {
-}
+AnyWaiters = 0;
-status = pthread_mutex_unlock(_mutex);
+pthread_cond_signal(_cond);
-assert_status(status == 0, status, "mutex_unlock");
+}
-if (AnyWaiters != 0) {
+status = pthread_mutex_unlock(_mutex);
-status = pthread_cond_signal(_cond);
+assert_status(status == 0, status, "mutex_unlock");
-assert_status(status == 0, status, "cond_signal");
+if (AnyWaiters != 0) {
-}
+status = pthread_cond_signal(_cond);
+assert_status(status == 0, status, "cond_signal");
 }
 // Note that we signal() _after dropping the lock for "immortal" Events.
 // This is safe and avoids a common class of  futile wakeups.  In rare
 // circumstances this can cause a thread to return prematurely from
 assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
 }
 void Parker::park(bool isAbsolute, jlong time) {
+// Ideally we'd do something useful while spinning, such
+// as calling unpackTime().
 // Optional fast-path check:
 // Return immediately if a permit is available.
-if (_counter > 0) {
+// We depend on Atomic::xchg() having full barrier semantics
-_counter = 0 ;
+// since we are doing a lock-free update to _counter.
-OrderAccess::fence();
+if (Atomic::xchg(0, &_counter) > 0) return;
-return ;
-}
 Thread* thread = Thread::current();
 assert(thread->is_Java_thread(), "Must be JavaThread");
 JavaThread *jt = (JavaThread *)thread;
 int status ;
 if (_counter > 0)  { // no wait needed
 _counter = 0;
 status = pthread_mutex_unlock(_mutex);
 assert (status == 0, "invariant") ;
+// Paranoia to ensure our locked and lock-free paths interact
+// correctly with each other and Java-level accesses.
 OrderAccess::fence();
 return;
 }
 #ifdef ASSERT
 #endif
 _counter = 0 ;
 status = pthread_mutex_unlock(_mutex) ;
 assert_status(status == 0, status, "invariant") ;
+// Paranoia to ensure our locked and lock-free paths interact
+// correctly with each other and Java-level accesses.
+OrderAccess::fence();
 // If externally suspended while waiting, re-suspend
 if (jt->handle_special_suspend_equivalent_condition()) {
 jt->java_suspend_self();
 }
-OrderAccess::fence();
 }
 void Parker::unpark() {
 int s, status ;
 status = pthread_mutex_lock(_mutex);

Mercurial > hg > truffle

comparison src/os/linux/vm/os_linux.cpp @ 7643:3ac7d10a6572