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

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 // CASPTR() uses the canonical argument order that dominates in the literature.
 // Our internal cmpxchg_ptr() uses a bastardized ordering to accommodate Sun .il templates.
-#define CASPTR(a,c,s) intptr_t(Atomic::cmpxchg_ptr ((void *)(s),(void *)(a),(void *)(c)))
+#define CASPTR(a, c, s)  \
+intptr_t(Atomic::cmpxchg_ptr((void *)(s), (void *)(a), (void *)(c)))
 #define UNS(x) (uintptr_t(x))
-#define TRACE(m) { static volatile int ctr = 0; int x = ++ctr; if ((x & (x-1))==0) { ::printf ("%d:%s\n", x, #m); ::fflush(stdout); }}
+#define TRACE(m)                   \
+{                                \
+static volatile int ctr = 0;   \
+int x = ++ctr;                 \
+if ((x & (x - 1)) == 0) {      \
+::printf("%d:%s\n", x, #m);  \
+::fflush(stdout);            \
+}                              \
+}
 // Simplistic low-quality Marsaglia SHIFT-XOR RNG.
 // Bijective except for the trailing mask operation.
 // Useful for spin loops as the compiler can't optimize it away.
-static inline jint MarsagliaXORV (jint x) {
+static inline jint MarsagliaXORV(jint x) {
 if (x == 0) x = 1|os::random();
 x ^= x << 6;
 x ^= ((unsigned)x) >> 21;
 x ^= x << 7;
 return x & 0x7FFFFFFF;
 }
-static int Stall (int its) {
+static int Stall(int its) {
 static volatile jint rv = 1;
 volatile int OnFrame = 0;
 jint v = rv ^ UNS(OnFrame);
 while (--its >= 0) {
 v = MarsagliaXORV(v);
 // scalability.
 //
 // Clamp spinning at approximately 1/2 of a context-switch round-trip.
 // See synchronizer.cpp for details and rationale.
-int Monitor::TrySpin (Thread * const Self) {
+int Monitor::TrySpin(Thread * const Self) {
 if (TryLock())    return 1;
 if (!os::is_MP()) return 0;
 int Probes  = 0;
 int Delay   = 0;
 Stall(Delay);
 }
 }
 }
-static int ParkCommon (ParkEvent * ev, jlong timo) {
+static int ParkCommon(ParkEvent * ev, jlong timo) {
 // Diagnostic support - periodically unwedge blocked threads
 intx nmt = NativeMonitorTimeout;
 if (nmt > 0 && (nmt < timo || timo <= 0)) {
 timo = nmt;
 }
 err = ev->park(timo);
 }
 return err;
 }
-inline int Monitor::AcquireOrPush (ParkEvent * ESelf) {
+inline int Monitor::AcquireOrPush(ParkEvent * ESelf) {
 intptr_t v = _LockWord.FullWord;
 for (;;) {
 if ((v & _LBIT) == 0) {
 const intptr_t u = CASPTR(&_LockWord, v, v|_LBIT);
 if (u == v) return 1;        // indicate acquired
 // performed any needed state transitions beforehand.
 // IWait and ILock may directly call park() without any concern for thread state.
 // Note that ILock and IWait do *not* access _owner.
 // _owner is a higher-level logical concept.
-void Monitor::ILock (Thread * Self) {
+void Monitor::ILock(Thread * Self) {
 assert(_OnDeck != Self->_MutexEvent, "invariant");
 if (TryFast()) {
 Exeunt:
 assert(ILocked(), "invariant");
 // Note that (A) and (B) are tantamount to succession by direct handoff for
 // the inner lock.
 goto Exeunt;
 }
-void Monitor::IUnlock (bool RelaxAssert) {
+void Monitor::IUnlock(bool RelaxAssert) {
 assert(ILocked(), "invariant");
 // Conceptually we need a MEMBAR #storestore|#loadstore barrier or fence immediately
 // before the store that releases the lock.  Crucially, all the stores and loads in the
 // critical section must be globally visible before the store of 0 into the lock-word
 // that releases the lock becomes globally visible.  That is, memory accesses in the
 ParkEvent * const w = List;
 assert(RelaxAssert || w != Thread::current()->_MutexEvent, "invariant");
 _EntryList = w->ListNext;
 // as a diagnostic measure consider setting w->_ListNext = BAD
 assert(UNS(_OnDeck) == _LBIT, "invariant");
-_OnDeck = w;           // pass OnDeck to w.
+_OnDeck = w;  // pass OnDeck to w.
 // w will clear OnDeck once it acquires the outer lock
 // Another optional optimization ...
 // For heavily contended locks it's not uncommon that some other
 // thread acquired the lock while this thread was arranging succession.
 // Try to defer the unpark() operation - Delegate the responsibility
 assert(ILocked(), "invariant");
 while (_WaitSet != NULL) notify();
 return true;
 }
-int Monitor::IWait (Thread * Self, jlong timo) {
+int Monitor::IWait(Thread * Self, jlong timo) {
 assert(ILocked(), "invariant");
 // Phases:
 // 1. Enqueue Self on WaitSet - currently prepend
 // 2. unlock - drop the outer lock
 //
 // But of course the proper ultimate approach is to avoid schemes that require explicit
 // sneaking or dependence on any any clever invariants or subtle implementation properties
 // of Mutex-Monitor and instead directly address the underlying design flaw.
-void Monitor::lock (Thread * Self) {
+void Monitor::lock(Thread * Self) {
 #ifdef CHECK_UNHANDLED_OOPS
 // Clear unhandled oops so we get a crash right away.  Only clear for non-vm
 // or GC threads.
 if (Self->is_Java_thread()) {
 Self->clear_unhandled_oops();
 }
 #endif // CHECK_UNHANDLED_OOPS
 debug_only(check_prelock_state(Self));
-assert(_owner != Self              , "invariant");
+assert(_owner != Self, "invariant");
 assert(_OnDeck != Self->_MutexEvent, "invariant");
 if (TryFast()) {
 Exeunt:
 assert(ILocked(), "invariant");
 // Lock without safepoint check - a degenerate variant of lock().
 // Should ONLY be used by safepoint code and other code
 // that is guaranteed not to block while running inside the VM. If this is called with
 // thread state set to be in VM, the safepoint synchronization code will deadlock!
-void Monitor::lock_without_safepoint_check (Thread * Self) {
+void Monitor::lock_without_safepoint_check(Thread * Self) {
 assert(_owner != Self, "invariant");
 ILock(Self);
 assert(_owner == NULL, "invariant");
 set_owner(Self);
 }
 }
 return false;
 }
 void Monitor::unlock() {
-assert(_owner  == Thread::current(), "invariant");
+assert(_owner == Thread::current(), "invariant");
-assert(_OnDeck != Thread::current()->_MutexEvent , "invariant");
+assert(_OnDeck != Thread::current()->_MutexEvent, "invariant");
 set_owner(NULL);
 if (_snuck) {
 assert(SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread(), "sneak");
 _snuck = false;
 return;
 return;
 }
 IUnlock(false);
 }
-bool Monitor::wait(bool no_safepoint_check, long timeout, bool as_suspend_equivalent) {
+bool Monitor::wait(bool no_safepoint_check, long timeout,
+bool as_suspend_equivalent) {
 Thread * const Self = Thread::current();
 assert(_owner == Self, "invariant");
 assert(ILocked(), "invariant");
 // as_suspend_equivalent logically implies !no_safepoint_check
 Monitor::~Monitor() {
 assert((UNS(_owner)|UNS(_LockWord.FullWord)|UNS(_EntryList)|UNS(_WaitSet)|UNS(_OnDeck)) == 0, "");
 }
-void Monitor::ClearMonitor (Monitor * m, const char *name) {
+void Monitor::ClearMonitor(Monitor * m, const char *name) {
 m->_owner             = NULL;
 m->_snuck             = false;
 if (name == NULL) {
 strcpy(m->_name, "UNKNOWN");
 } else {
 m->_WaitLock[0]       = 0;
 }
 Monitor::Monitor() { ClearMonitor(this); }
-Monitor::Monitor (int Rank, const char * name, bool allow_vm_block) {
+Monitor::Monitor(int Rank, const char * name, bool allow_vm_block) {
 ClearMonitor(this, name);
 #ifdef ASSERT
 _allow_vm_block  = allow_vm_block;
 _rank            = Rank;
 #endif
 Mutex::~Mutex() {
 assert((UNS(_owner)|UNS(_LockWord.FullWord)|UNS(_EntryList)|UNS(_WaitSet)|UNS(_OnDeck)) == 0, "");
 }
-Mutex::Mutex (int Rank, const char * name, bool allow_vm_block) {
+Mutex::Mutex(int Rank, const char * name, bool allow_vm_block) {
 ClearMonitor((Monitor *) this, name);
 #ifdef ASSERT
 _allow_vm_block   = allow_vm_block;
 _rank             = Rank;
 #endif
 }
 bool Monitor::contains(Monitor* locks, Monitor * lock) {
 for (; locks != NULL; locks = locks->next()) {
-if (locks == lock)
+if (locks == lock) {
 return true;
+}
 }
 return false;
 }
 #endif
 assert(_owner == NULL, "setting the owner thread of an already owned mutex");
 _owner = new_owner; // set the owner
 // link "this" into the owned locks list
 #ifdef ASSERT  // Thread::_owned_locks is under the same ifdef
 Monitor* locks = get_least_ranked_lock(new_owner->owned_locks());
 // Mutex::set_owner_implementation is a friend of Thread
 assert(this->rank() >= 0, "bad lock rank");
 locks->name(), locks->rank()));
 }
 this->_next = new_owner->_owned_locks;
 new_owner->_owned_locks = this;
 #endif
 } else {
 // the thread is releasing this lock
 Thread* old_owner = _owner;
 assert(old_owner != NULL, "removing the owner thread of an unowned mutex");
 assert(old_owner == Thread::current(), "removing the owner thread of an unowned mutex");
 _owner = NULL; // set the owner
 #ifdef ASSERT
 Monitor *locks = old_owner->owned_locks();
 // remove "this" from the owned locks list
 Monitor *prev = NULL;
 old_owner->_owned_locks = _next;
 } else {
 prev->_next = _next;
 }
 _next = NULL;
 #endif
 }
 }
 // Factored out common sanity checks for locking mutex'es. Used by lock() and try_lock()

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 28163	322d55d167be