jdk-sandbox: comparison hotspot/src/os/solaris/vm/os

equal deleted inserted replaced

-:adbe834be3a0
+:eb5f1b4f01e1
 // an appropriate loop.  A litmus test for the correct
 // usage of park is the following: if park() were modified
 // to immediately return 0 your code should still work,
 // albeit degenerating to a spin loop.
 //
-// An interesting optimization for park() is to use a trylock()
+// In a sense, park()-unpark() just provides more polite spinning
-// to attempt to acquire the mutex.  If the trylock() fails
+// and polling with the key difference over naive spinning being
-// then we know that a concurrent unpark() operation is in-progress.
+// that a parked thread needs to be explicitly unparked() in order
-// in that case the park() code could simply set _count to 0
+// to wake up and to poll the underlying condition.
-// and return immediately.  The subsequent park() operation *might*
-// return immediately.  That's harmless as the caller of park() is
-// expected to loop.  By using trylock() we will have avoided a
-// avoided a context switch caused by contention on the per-thread mutex.
 //
-// TODO-FIXME:
+// Assumption:
-// 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the
+//    Only one parker can exist on an event, which is why we allocate
-//     objectmonitor implementation.
+//    them per-thread. Multiple unparkers can coexist.
-// 2.  Collapse the JSR166 parker event, and the
-//     objectmonitor ParkEvent into a single "Event" construct.
-// 3.  In park() and unpark() add:
-//     assert (Thread::current() == AssociatedWith).
-// 4.  add spurious wakeup injection on a -XX:EarlyParkReturn=N switch.
-//     1-out-of-N park() operations will return immediately.
 //
 // _Event transitions in park()
 //   -1 => -1 : illegal
 //    1 =>  0 : pass - return immediately
-//    0 => -1 : block
+//    0 => -1 : block; then set _Event to 0 before returning
+//
+// _Event transitions in unpark()
+//    0 => 1 : just return
+//    1 => 1 : just return
+//   -1 => either 0 or 1; must signal target thread
+//         That is, we can safely transition _Event from -1 to either
+//         0 or 1.
 //
 // _Event serves as a restricted-range semaphore.
+//   -1 : thread is blocked, i.e. there is a waiter
+//    0 : neutral: thread is running or ready,
+//        could have been signaled after a wait started
+//    1 : signaled - thread is running or ready
 //
 // Another possible encoding of _Event would be with
 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
 //
 // TODO-FIXME: add DTRACE probes for:
 abstime->tv_nsec = usec * 1000;
 return abstime;
 }
 void os::PlatformEvent::park() {           // AKA: down()
+// Transitions for _Event:
+//   -1 => -1 : illegal
+//    1 =>  0 : pass - return immediately
+//    0 => -1 : block; then set _Event to 0 before returning
 // Invariant: Only the thread associated with the Event/PlatformEvent
 // may call park().
 assert(_nParked == 0, "invariant");
 int v;
 OrderAccess::fence();
 }
 }
 int os::PlatformEvent::park(jlong millis) {
+// Transitions for _Event:
+//   -1 => -1 : illegal
+//    1 =>  0 : pass - return immediately
+//    0 => -1 : block; then set _Event to 0 before returning
 guarantee(_nParked == 0, "invariant");
 int v;
 for (;;) {
 v = _Event;
 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
 return ret;
 }
 void os::PlatformEvent::unpark() {
 // Transitions for _Event:
-//    0 :=> 1
+//    0 => 1 : just return
-//    1 :=> 1
+//    1 => 1 : just return
-//   -1 :=> either 0 or 1; must signal target thread
+//   -1 => either 0 or 1; must signal target thread
-//          That is, we can safely transition _Event from -1 to either
+//         That is, we can safely transition _Event from -1 to either
-//          0 or 1.
+//         0 or 1.
 // See also: "Semaphores in Plan 9" by Mullender & Cox
 //
 // Note: Forcing a transition from "-1" to "1" on an unpark() means
 // 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
 int AnyWaiters = _nParked;
 status = os::Solaris::mutex_unlock(_mutex);
 assert_status(status == 0, status, "mutex_unlock");
 guarantee(AnyWaiters == 0 || AnyWaiters == 1, "invariant");
 if (AnyWaiters != 0) {
-// We intentional signal *after* dropping the lock
+// Note that we signal() *after* dropping the lock for "immortal" Events.
-// to avoid a common class of futile wakeups.
+// This is safe and avoids a common class of  futile wakeups.  In rare
+// circumstances this can cause a thread to return prematurely from
+// cond_{timed}wait() but the spurious wakeup is benign and the victim
+// will simply re-test the condition and re-park itself.
+// This provides particular benefit if the underlying platform does not
+// provide wait morphing.
 status = os::Solaris::cond_signal(_cond);
 assert_status(status == 0, status, "cond_signal");
 }
 }

changeset 27458	eb5f1b4f01e1
parent 27400	c5955f4b7c84
child 27473	07948a5f8f5c
child 27471	6e56277909f1