graal-compiler: src/os/solaris/vm/os

comparison src/os/solaris/vm/os_solaris.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) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 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.
 }
 -- _nParked ;
 _Event = 0 ;
 status = os::Solaris::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();
 }
 }
 int os::PlatformEvent::park(jlong millis) {
 guarantee (_nParked == 0, "invariant") ;
 -- _nParked ;
 if (_Event >= 0) ret = OS_OK ;
 _Event = 0 ;
 status = os::Solaris::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();
 return ret;
 }
 void os::PlatformEvent::unpark() {
-int v, AnyWaiters;
+// Transitions for _Event:
+//    0 :=> 1
-// Increment _Event.
+//    1 :=> 1
-// Another acceptable implementation would be to simply swap 1
+//   -1 :=> either 0 or 1; must signal target thread
-// into _Event:
+//          That is, we can safely transition _Event from -1 to either
-//   if (Swap (&_Event, 1) < 0) {
+//          0 or 1. Forcing 1 is slightly more efficient for back-to-back
-//      mutex_lock (_mutex) ; AnyWaiters = nParked; mutex_unlock (_mutex) ;
+//          unpark() calls.
-//      if (AnyWaiters) cond_signal (_cond) ;
+// See also: "Semaphores in Plan 9" by Mullender & Cox
-//   }
+//
+// Note: Forcing a transition from "-1" to "1" on an unpark() means
-for (;;) {
+// that it will take two back-to-back park() calls for the owning
-v = _Event ;
+// thread to block. This has the benefit of forcing a spurious return
-if (v > 0) {
+// from the first park() call after an unpark() call which will help
-// The LD of _Event could have reordered or be satisfied
+// shake out uses of park() and unpark() without condition variables.
-// by a read-aside from this processor's write buffer.
-// To avoid problems execute a barrier and then
+if (Atomic::xchg(1, &_Event) >= 0) return;
-// ratify the value.  A degenerate CAS() would also work.
-// Viz., CAS (v+0, &_Event, v) == v).
-OrderAccess::fence() ;
-if (_Event == v) return ;
-continue ;
-}
-if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
-}
 // If the thread associated with the event was parked, wake it.
-if (v < 0) {
+// Wait for the thread assoc with the PlatformEvent to vacate.
-int status ;
+int status = os::Solaris::mutex_lock(_mutex);
-// Wait for the thread assoc with the PlatformEvent to vacate.
+assert_status(status == 0, status, "mutex_lock");
-status = os::Solaris::mutex_lock(_mutex);
+int AnyWaiters = _nParked;
-assert_status(status == 0, status, "mutex_lock");
+status = os::Solaris::mutex_unlock(_mutex);
-AnyWaiters = _nParked ;
+assert_status(status == 0, status, "mutex_unlock");
-status = os::Solaris::mutex_unlock(_mutex);
+guarantee(AnyWaiters == 0 || AnyWaiters == 1, "invariant");
-assert_status(status == 0, status, "mutex_unlock");
+if (AnyWaiters != 0) {
-guarantee (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ;
+// We intentional signal *after* dropping the lock
-if (AnyWaiters != 0) {
+// to avoid a common class of futile wakeups.
-// We intentional signal *after* dropping the lock
+status = os::Solaris::cond_signal(_cond);
-// to avoid a common class of futile wakeups.
+assert_status(status == 0, status, "cond_signal");
-status = os::Solaris::cond_signal(_cond);
-assert_status(status == 0, status, "cond_signal");
-}
 }
 }
 // JSR166
 // -------------------------------------------------------
 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 ;
-}
 // Optional fast-exit: Check interrupt before trying to wait
 Thread* thread = Thread::current();
 assert(thread->is_Java_thread(), "Must be JavaThread");
 JavaThread *jt = (JavaThread *)thread;
 if (_counter > 0)  { // no wait needed
 _counter = 0;
 status = os::Solaris::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
 thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
 #endif
 _counter = 0 ;
 status = os::Solaris::mutex_unlock(_mutex);
 assert_status(status == 0, status, "mutex_unlock") ;
+// 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 = os::Solaris::mutex_lock (_mutex) ;

Mercurial > hg > graal-compiler

comparison src/os/solaris/vm/os_solaris.cpp @ 7643:3ac7d10a6572