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

equal deleted inserted replaced

-:2c6c0fabe6a2
+:043ae846819f
 #include "memory/allocation.hpp"
 #include "runtime/os.hpp"
 #include "utilities/histogram.hpp"
-// The SplitWord construct allows us to colocate the contention queue
-// (cxq) with the lock-byte.  The queue elements are ParkEvents, which are
+// A Mutex/Monitor is a simple wrapper around a native lock plus condition
-// always aligned on 256-byte addresses - the least significant byte of
+// variable that supports lock ownership tracking, lock ranking for deadlock
-// a ParkEvent is always 0.  Colocating the lock-byte with the queue
+// detection and coordinates with the safepoint protocol.
-// allows us to easily avoid what would otherwise be a race in lock()
-// if we were to use two completely separate fields for the contention queue
-// and the lock indicator.  Specifically, colocation renders us immune
-// from the race where a thread might enqueue itself in the lock() slow-path
-// immediately after the lock holder drops the outer lock in the unlock()
-// fast-path.
-//
-// Colocation allows us to use a fast-path unlock() form that uses
-// A MEMBAR instead of a CAS.  MEMBAR has lower local latency than CAS
-// on many platforms.
-//
-// See:
-// +  http://blogs.sun.com/dave/entry/biased_locking_in_hotspot
-// +  http://blogs.sun.com/dave/resource/synchronization-public2.pdf
-//
-// Note that we're *not* using word-tearing the classic sense.
-// The lock() fast-path will CAS the lockword and the unlock()
-// fast-path will store into the lock-byte colocated within the lockword.
-// We depend on the fact that all our reference platforms have
-// coherent and atomic byte accesses.  More precisely, byte stores
-// interoperate in a safe, sane, and expected manner with respect to
-// CAS, ST and LDs to the full-word containing the byte.
-// If you're porting HotSpot to a platform where that isn't the case
-// then you'll want change the unlock() fast path from:
-//    STB;MEMBAR #storeload; LDN
-// to a full-word CAS of the lockword.
-union SplitWord {   // full-word with separately addressable LSB
-volatile intptr_t FullWord ;
-volatile void * Address ;
-volatile jbyte Bytes [sizeof(intptr_t)] ;
-} ;
-class ParkEvent ;
-// See orderAccess.hpp.  We assume throughout the VM that mutex lock and
-// try_lock do fence-lock-acquire, and that unlock does a release-unlock,
-// *in that order*.  If their implementations change such that these
-// assumptions are violated, a whole lot of code will break.
 // The default length of monitor name was originally chosen to be 64 to avoid
 // false sharing. Now, PaddedMonitor is available for this purpose.
 // TODO: Check if _name[MONITOR_NAME_LEN] should better get replaced by const char*.
 static const int MONITOR_NAME_LEN = 64;
 nonleaf        = barrier        +   1,
 max_nonleaf    = nonleaf        + 900,
 native         = max_nonleaf    +   1
 };
-// The WaitSet and EntryList linked lists are composed of ParkEvents.
-// I use ParkEvent instead of threads as ParkEvents are immortal and
-// type-stable, meaning we can safely unpark() a possibly stale
-// list element in the unlock()-path.
 protected:                              // Monitor-Mutex metadata
-SplitWord _LockWord ;                  // Contention queue (cxq) colocated with Lock-byte
 Thread * volatile _owner;              // The owner of the lock
-// Consider sequestering _owner on its own $line
+os::PlatformMonitor _lock;             // Native monitor implementation
-// to aid future synchronization mechanisms.
+char _name[MONITOR_NAME_LEN];          // Name of mutex/monitor
-ParkEvent * volatile _EntryList ;      // List of threads waiting for entry
-ParkEvent * volatile _OnDeck ;         // heir-presumptive
-volatile intptr_t _WaitLock [1] ;      // Protects _WaitSet
-ParkEvent * volatile  _WaitSet ;       // LL of ParkEvents
-volatile bool     _snuck;              // Used for sneaky locking (evil).
-char _name[MONITOR_NAME_LEN];          // Name of mutex
 // Debugging fields for naming, deadlock detection, etc. (some only used in debug mode)
 #ifndef PRODUCT
 bool      _allow_vm_block;
 DEBUG_ONLY(int _rank;)                 // rank (to avoid/detect potential deadlocks)
 #endif
 void set_owner_implementation(Thread* owner)                        PRODUCT_RETURN;
 void check_prelock_state     (Thread* thread, bool safepoint_check) PRODUCT_RETURN;
 void check_block_state       (Thread* thread)                       PRODUCT_RETURN;
+void assert_owner            (Thread* expected)                     NOT_DEBUG_RETURN;
-// platform-dependent support code can go here (in os_<os_family>.cpp)
 public:
 enum {
 _no_safepoint_check_flag    = true,
 _allow_vm_block_flag        = true,
 _as_suspend_equivalent_flag = true
 // Monitor::lock and Monitor::lock_without_safepoint_check
 // checks these flags when acquiring a lock to ensure
 // consistent checking for each lock.
 // A few existing locks will sometimes have a safepoint check and
 // sometimes not, but these locks are set up in such a way to avoid deadlocks.
+// Note: monitors that may be shared between JavaThreads and the VMThread
+// should never encounter a safepoint check whilst they are held, else a
+// deadlock with the VMThread can occur.
 enum SafepointCheckRequired {
 _safepoint_check_never,       // Monitors with this value will cause errors
 // when acquired with a safepoint check.
 _safepoint_check_sometimes,   // Certain locks are called sometimes with and
 // sometimes without safepoint checks. These
 // check.
 };
 NOT_PRODUCT(SafepointCheckRequired _safepoint_check_required;)
-enum WaitResults {
-CONDVAR_EVENT,         // Wait returned because of condition variable notification
-INTERRUPT_EVENT,       // Wait returned because waiting thread was interrupted
-NUMBER_WAIT_RESULTS
-};
-private:
-int  TrySpin (Thread * Self) ;
-int  TryLock () ;
-int  TryFast () ;
-int  AcquireOrPush (ParkEvent * ev) ;
-void IUnlock (bool RelaxAssert) ;
-void ILock (Thread * Self) ;
-int  IWait (Thread * Self, jlong timo);
-int  ILocked () ;
 protected:
 static void ClearMonitor (Monitor * m, const char* name = NULL) ;
 Monitor() ;
 public:
 // zero), and not a suspend-equivalent condition. Returns true if wait
 // times out; otherwise returns false.
 bool wait(bool no_safepoint_check = !_no_safepoint_check_flag,
 long timeout = 0,
 bool as_suspend_equivalent = !_as_suspend_equivalent_flag);
-bool notify();
+void notify();
-bool notify_all();
+void notify_all();
 void lock(); // prints out warning if VM thread blocks
 void lock(Thread *thread); // overloaded with current thread
 void unlock();
 bool is_locked() const                     { return _owner != NULL; }
 bool try_lock(); // Like lock(), but unblocking. It returns false instead
+void release_for_safepoint();
 // Lock without safepoint check. Should ONLY be used by safepoint code and other code
 // that is guaranteed not to block while running inside the VM.
 void lock_without_safepoint_check();
 void lock_without_safepoint_check (Thread * Self) ;
 // An even better alternative is to simply eliminate Mutex:: and use Monitor:: instead.
 // After all, monitors are sufficient for Java-level synchronization.   At one point in time
 // there may have been some benefit to having distinct mutexes and monitors, but that time
 // has past.
 //
-// The Mutex/Monitor design parallels that of Java-monitors, being based on
-// thread-specific park-unpark platform-specific primitives.
 class Mutex : public Monitor {      // degenerate Monitor
 public:
 Mutex(int rank, const char *name, bool allow_vm_block = false,
 SafepointCheckRequired safepoint_check_required = _safepoint_check_always);
 // default destructor
 private:
-bool notify ()    { ShouldNotReachHere(); return false; }
+void notify ()    { ShouldNotReachHere(); }
-bool notify_all() { ShouldNotReachHere(); return false; }
+void notify_all() { ShouldNotReachHere(); }
 bool wait (bool no_safepoint_check, long timeout, bool as_suspend_equivalent) {
 ShouldNotReachHere() ;
 return false ;
 }
 };

changeset 53646	043ae846819f
parent 53244	9807daeb47c4
child 53775	5d20b085d893