< prev index next >

src/hotspot/share/runtime/mutex.hpp

Print this page

        

@@ -35,11 +35,11 @@
 // 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;
 
-class Monitor : public CHeapObj<mtSynchronizer> {
+class Mutex : public CHeapObj<mtSynchronizer> {
 
  public:
   // A special lock: Is a lock where you are guaranteed not to block while you are
   // holding it, i.e., no vm operation can happen, taking other (blocking) locks, etc.
   // The rank 'access' is similar to 'special' and has the same restrictions on usage.

@@ -82,23 +82,22 @@
 
   // 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)
-  DEBUG_ONLY(Monitor * _next;)           // Used by a Thread to link up owned locks
+  DEBUG_ONLY(Mutex* _next;)              // Used by a Thread to link up owned locks
   DEBUG_ONLY(Thread* _last_owner;)       // the last thread to own the lock
-  DEBUG_ONLY(static bool contains(Monitor * locks, Monitor * lock);)
-  DEBUG_ONLY(static Monitor * get_least_ranked_lock(Monitor * locks);)
-  DEBUG_ONLY(Monitor * get_least_ranked_lock_besides_this(Monitor * locks);)
+  DEBUG_ONLY(static bool contains(Mutex* locks, Mutex* lock);)
+  DEBUG_ONLY(static Mutex* get_least_ranked_lock(Mutex* locks);)
+  DEBUG_ONLY(Mutex* get_least_ranked_lock_besides_this(Mutex* locks);)
 #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 check_safepoint_state   (Thread* thread, bool safepoint_check) NOT_DEBUG_RETURN;
   void assert_owner            (Thread* expected)                     NOT_DEBUG_RETURN;
-  void assert_wait_lock_state  (Thread* self)                         NOT_DEBUG_RETURN;
 
  public:
   enum {
     _allow_vm_block_flag        = true,
     _as_suspend_equivalent_flag = true

@@ -128,36 +127,25 @@
     _safepoint_check_flag,
     _no_safepoint_check_flag
   };
 
   enum SafepointCheckRequired {
-    _safepoint_check_never,       // Monitors with this value will cause errors
+    _safepoint_check_never,       // Mutexes with this value will cause errors
                                   // when acquired by a JavaThread with a safepoint check.
     _safepoint_check_sometimes,   // A couple of special locks are acquired by JavaThreads sometimes
                                   // with and sometimes without safepoint checks. These
                                   // locks will not produce errors when locked.
-    _safepoint_check_always       // Monitors with this value will cause errors
+    _safepoint_check_always       // Mutexes with this value will cause errors
                                   // when acquired by a JavaThread without a safepoint check.
   };
 
   NOT_PRODUCT(SafepointCheckRequired _safepoint_check_required;)
 
  public:
-  Monitor(int rank, const char *name, bool allow_vm_block = false,
+  Mutex(int rank, const char *name, bool allow_vm_block = false,
           SafepointCheckRequired safepoint_check_required = _safepoint_check_always);
-  ~Monitor();
-
-  // Wait until monitor is notified (or times out).
-  // Defaults are to make safepoint checks, wait time is forever (i.e.,
-  // zero), and not a suspend-equivalent condition. Returns true if wait
-  // times out; otherwise returns false.
-  bool wait(long timeout = 0,
-            bool as_suspend_equivalent = !_as_suspend_equivalent_flag);
-  bool wait_without_safepoint_check(long timeout = 0);
-  void notify();
-  void notify_all();
-
+  ~Mutex();
 
   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; }

@@ -184,70 +172,47 @@
     void print_on(outputStream* st) const;
     void print() const                      { print_on(::tty); }
     DEBUG_ONLY(int    rank() const          { return _rank; })
     bool   allow_vm_block()                 { return _allow_vm_block; }
 
-    DEBUG_ONLY(Monitor *next()  const         { return _next; })
-    DEBUG_ONLY(void   set_next(Monitor *next) { _next = next; })
+    DEBUG_ONLY(Mutex *next()  const         { return _next; })
+    DEBUG_ONLY(void   set_next(Mutex *next) { _next = next; })
   #endif
 
   void set_owner(Thread* owner) {
   #ifndef PRODUCT
     set_owner_implementation(owner);
-    DEBUG_ONLY(void verify_Monitor(Thread* thr);)
+    DEBUG_ONLY(void verify_mutex(Thread* thr);)
   #else
     _owner = owner;
   #endif
   }
 
 };
 
-class PaddedMonitor : public Monitor {
-  enum {
-    CACHE_LINE_PADDING = (int)DEFAULT_CACHE_LINE_SIZE - (int)sizeof(Monitor),
-    PADDING_LEN = CACHE_LINE_PADDING > 0 ? CACHE_LINE_PADDING : 1
-  };
-  char _padding[PADDING_LEN];
- public:
-  PaddedMonitor(int rank, const char *name, bool allow_vm_block = false,
-               SafepointCheckRequired safepoint_check_required = _safepoint_check_always) :
-    Monitor(rank, name, allow_vm_block, safepoint_check_required) {};
-};
 
-// Normally we'd expect Monitor to extend Mutex in the sense that a monitor
-// constructed from pthreads primitives might extend a mutex by adding
-// a condvar and some extra metadata.  In fact this was the case until J2SE7.
-//
-// Currently, however, the base object is a monitor.  Monitor contains all the
-// logic for wait(), notify(), etc.   Mutex extends monitor and restricts the
-// visibility of wait(), notify(), and notify_all().
-//
-// Another viable alternative would have been to have Monitor extend Mutex and
-// implement all the normal mutex and wait()-notify() logic in Mutex base class.
-// The wait()-notify() facility would be exposed via special protected member functions
-// (e.g., _Wait() and _Notify()) in Mutex.  Monitor would extend Mutex and expose wait()
-// as a call to _Wait().  That is, the public wait() would be a wrapper for the protected
-// _Wait().
-//
-// 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 passed.
-//
+// PlatformMonitor extends PlatformMutex so this makes sense.
 
-class Mutex : public Monitor {      // degenerate Monitor
+class Monitor : public Mutex {
+  void assert_wait_lock_state  (Thread* self)                         NOT_DEBUG_RETURN;
  public:
-   Mutex(int rank, const char *name, bool allow_vm_block = false,
+   Monitor(int rank, const char *name, bool allow_vm_block = false,
          SafepointCheckRequired safepoint_check_required = _safepoint_check_always);
    // default destructor
- private:
+
+  // Wait until monitor is notified (or times out).
+  // Defaults are to make safepoint checks, wait time is forever (i.e.,
+  // zero), and not a suspend-equivalent condition. Returns true if wait
+  // times out; otherwise returns false.
+  bool wait(long timeout = 0,
+            bool as_suspend_equivalent = !_as_suspend_equivalent_flag);
+  bool wait_without_safepoint_check(long timeout = 0);
    void notify();
    void notify_all();
-   bool wait(long timeout, bool as_suspend_equivalent);
-   bool wait_without_safepoint_check(long timeout);
 };
 
+
 class PaddedMutex : public Mutex {
   enum {
     CACHE_LINE_PADDING = (int)DEFAULT_CACHE_LINE_SIZE - (int)sizeof(Mutex),
     PADDING_LEN = CACHE_LINE_PADDING > 0 ? CACHE_LINE_PADDING : 1
   };

@@ -256,6 +221,18 @@
   PaddedMutex(int rank, const char *name, bool allow_vm_block = false,
               SafepointCheckRequired safepoint_check_required = _safepoint_check_always) :
     Mutex(rank, name, allow_vm_block, safepoint_check_required) {};
 };
 
+class PaddedMonitor : public Monitor {
+  enum {
+    CACHE_LINE_PADDING = (int)DEFAULT_CACHE_LINE_SIZE - (int)sizeof(Monitor),
+    PADDING_LEN = CACHE_LINE_PADDING > 0 ? CACHE_LINE_PADDING : 1
+  };
+  char _padding[PADDING_LEN];
+ public:
+  PaddedMonitor(int rank, const char *name, bool allow_vm_block = false,
+               SafepointCheckRequired safepoint_check_required = _safepoint_check_always) :
+    Monitor(rank, name, allow_vm_block, safepoint_check_required) {};
+};
+
 #endif // SHARE_RUNTIME_MUTEX_HPP
< prev index next >