< prev index next >

src/hotspot/share/runtime/objectMonitor.hpp

Print this page
rev 56044 : imported patch 8230184.patch
rev 56046 : v2.00 -> v2.05 (CR5/v2.05/8-for-jdk13) patches combined into one; merge with 8229212.patch; merge with jdk-14+11; merge with 8230184.patch.


 120 //     _recursions, _EntryList, _cxq, and _succ, all of which may be
 121 //     fetched in the inflated unlock path, on a different cache line
 122 //     would make them immune to CAS-based invalidation from the _owner
 123 //     field.
 124 //
 125 //   - The _recursions field should be of type int, or int32_t but not
 126 //     intptr_t. There's no reason to use a 64-bit type for this field
 127 //     in a 64-bit JVM.
 128 
 129 class ObjectMonitor {
 130  public:
 131   enum {
 132     OM_OK,                    // no error
 133     OM_SYSTEM_ERROR,          // operating system error
 134     OM_ILLEGAL_MONITOR_STATE, // IllegalMonitorStateException
 135     OM_INTERRUPTED,           // Thread.interrupt()
 136     OM_TIMED_OUT              // Object.wait() timed out
 137   };
 138 
 139  private:

 140   friend class ObjectSynchronizer;
 141   friend class ObjectWaiter;
 142   friend class VMStructs;
 143   JVMCI_ONLY(friend class JVMCIVMStructs;)
 144 
 145   // The sync code expects the header field to be at offset zero (0).
 146   // Enforced by the assert() in header_addr().
 147   volatile markWord _header;        // displaced object header word - mark
 148   void* volatile _object;           // backward object pointer - strong root
 149  public:
 150   ObjectMonitor* _next_om;          // Next ObjectMonitor* linkage
 151  private:
 152   // Separate _header and _owner on different cache lines since both can
 153   // have busy multi-threaded access. _header and _object are set at
 154   // initial inflation and _object doesn't change until deflation so
 155   // _object is a good choice to share the cache line with _header.
 156   // _next_om shares _header's cache line for pre-monitor list historical
 157   // reasons. _next_om only changes if the next ObjectMonitor is deflated.
 158   DEFINE_PAD_MINUS_SIZE(0, DEFAULT_CACHE_LINE_SIZE,
 159                         sizeof(volatile markWord) + sizeof(void* volatile) +
 160                         sizeof(ObjectMonitor *));


 161  protected:                         // protected for JvmtiRawMonitor
 162   void* volatile _owner;            // pointer to owning thread OR BasicLock
 163  private:
 164   volatile jlong _previous_owner_tid;  // thread id of the previous owner of the monitor
 165  protected:                         // protected for JvmtiRawMonitor
 166   volatile intptr_t _recursions;    // recursion count, 0 for first entry
 167   ObjectWaiter* volatile _EntryList;  // Threads blocked on entry or reentry.
 168                                       // The list is actually composed of WaitNodes,
 169                                       // acting as proxies for Threads.
 170  private:
 171   ObjectWaiter* volatile _cxq;      // LL of recently-arrived threads blocked on entry.
 172   Thread* volatile _succ;           // Heir presumptive thread - used for futile wakeup throttling
 173   Thread* volatile _Responsible;
 174 
 175   volatile int _Spinner;            // for exit->spinner handoff optimization
 176   volatile int _SpinDuration;
 177 
 178   volatile jint  _contentions;      // Number of active contentions in enter(). It is used by is_busy()
 179                                     // along with other fields to determine if an ObjectMonitor can be
 180                                     // deflated. See ObjectSynchronizer::deflate_monitor().

 181  protected:
 182   ObjectWaiter* volatile _WaitSet;  // LL of threads wait()ing on the monitor
 183   volatile jint  _waiters;          // number of waiting threads
 184  private:
 185   volatile int _WaitSetLock;        // protects Wait Queue - simple spinlock








 186 
 187  public:
 188   static void Initialize();
 189 
 190   // Only perform a PerfData operation if the PerfData object has been
 191   // allocated and if the PerfDataManager has not freed the PerfData
 192   // objects which can happen at normal VM shutdown.
 193   //
 194   #define OM_PERFDATA_OP(f, op_str)              \
 195     do {                                         \
 196       if (ObjectMonitor::_sync_ ## f != NULL &&  \
 197           PerfDataManager::has_PerfData()) {     \
 198         ObjectMonitor::_sync_ ## f->op_str;      \
 199       }                                          \
 200     } while (0)
 201 
 202   static PerfCounter * _sync_ContendedLockAttempts;
 203   static PerfCounter * _sync_FutileWakeups;
 204   static PerfCounter * _sync_Parks;
 205   static PerfCounter * _sync_Notifications;


 227   // ObjectMonitor references can be ORed with markWord::monitor_value
 228   // as part of the ObjectMonitor tagging mechanism. When we combine an
 229   // ObjectMonitor reference with an offset, we need to remove the tag
 230   // value in order to generate the proper address.
 231   //
 232   // We can either adjust the ObjectMonitor reference and then add the
 233   // offset or we can adjust the offset that is added to the ObjectMonitor
 234   // reference. The latter avoids an AGI (Address Generation Interlock)
 235   // stall so the helper macro adjusts the offset value that is returned
 236   // to the ObjectMonitor reference manipulation code:
 237   //
 238   #define OM_OFFSET_NO_MONITOR_VALUE_TAG(f) \
 239     ((ObjectMonitor::f ## _offset_in_bytes()) - markWord::monitor_value)
 240 
 241   markWord           header() const;
 242   volatile markWord* header_addr();
 243   void               set_header(markWord hdr);
 244 
 245   intptr_t is_busy() const {
 246     // TODO-FIXME: assert _owner == null implies _recursions = 0
 247     return _contentions|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList);












 248   }
 249   const char* is_busy_to_string(stringStream* ss);
 250 
 251   intptr_t  is_entered(Thread* current) const;
 252 
 253   void*     owner() const;


 254   void      set_owner(void* owner);
 255 
 256   jint      waiters() const;
 257 
 258   jint      contentions() const;
 259   intptr_t  recursions() const                                         { return _recursions; }
 260 
 261   // JVM/TI GetObjectMonitorUsage() needs this:
 262   ObjectWaiter* first_waiter()                                         { return _WaitSet; }
 263   ObjectWaiter* next_waiter(ObjectWaiter* o)                           { return o->_next; }
 264   Thread* thread_of_waiter(ObjectWaiter* o)                            { return o->_thread; }
 265 
 266  protected:
 267   // We don't typically expect or want the ctors or dtors to run.
 268   // normal ObjectMonitors are type-stable and immortal.
 269   ObjectMonitor() { ::memset((void*)this, 0, sizeof(*this)); }
 270 
 271   ~ObjectMonitor() {
 272     // TODO: Add asserts ...
 273     // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0


 278   void Recycle() {
 279     // TODO: add stronger asserts ...
 280     // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0
 281     // _contentions == 0 EntryList  == NULL
 282     // _recursions == 0 _WaitSet == NULL
 283     DEBUG_ONLY(stringStream ss;)
 284     assert((is_busy() | _recursions) == 0, "freeing in-use monitor: %s, "
 285            "recursions=" INTPTR_FORMAT, is_busy_to_string(&ss), _recursions);
 286     _succ          = NULL;
 287     _EntryList     = NULL;
 288     _cxq           = NULL;
 289     _WaitSet       = NULL;
 290     _recursions    = 0;
 291   }
 292 
 293  public:
 294 
 295   void*     object() const;
 296   void*     object_addr();
 297   void      set_object(void* obj);









 298 
 299   // Returns true if the specified thread owns the ObjectMonitor. Otherwise
 300   // returns false and throws IllegalMonitorStateException (IMSE).
 301   bool      check_owner(Thread* THREAD);
 302   void      clear();

 303 
 304   void      enter(TRAPS);
 305   void      exit(bool not_suspended, TRAPS);
 306   void      wait(jlong millis, bool interruptable, TRAPS);
 307   void      notify(TRAPS);
 308   void      notifyAll(TRAPS);
 309 
 310   void      print() const;
 311   void      print_on(outputStream* st) const;
 312 
 313 // Use the following at your own risk
 314   intptr_t  complete_exit(TRAPS);
 315   void      reenter(intptr_t recursions, TRAPS);
 316 
 317  private:
 318   void      AddWaiter(ObjectWaiter* waiter);
 319   void      INotify(Thread* self);
 320   ObjectWaiter* DequeueWaiter();
 321   void      DequeueSpecificWaiter(ObjectWaiter* waiter);
 322   void      EnterI(TRAPS);
 323   void      ReenterI(Thread* self, ObjectWaiter* self_node);
 324   void      UnlinkAfterAcquire(Thread* self, ObjectWaiter* self_node);
 325   int       TryLock(Thread* self);
 326   int       NotRunnable(Thread* self, Thread * Owner);
 327   int       TrySpin(Thread* self);
 328   void      ExitEpilog(Thread* self, ObjectWaiter* Wakee);
 329   bool      ExitSuspendEquivalent(JavaThread* self);

 330 };































 331 
 332 #endif // SHARE_RUNTIME_OBJECTMONITOR_HPP


 120 //     _recursions, _EntryList, _cxq, and _succ, all of which may be
 121 //     fetched in the inflated unlock path, on a different cache line
 122 //     would make them immune to CAS-based invalidation from the _owner
 123 //     field.
 124 //
 125 //   - The _recursions field should be of type int, or int32_t but not
 126 //     intptr_t. There's no reason to use a 64-bit type for this field
 127 //     in a 64-bit JVM.
 128 
 129 class ObjectMonitor {
 130  public:
 131   enum {
 132     OM_OK,                    // no error
 133     OM_SYSTEM_ERROR,          // operating system error
 134     OM_ILLEGAL_MONITOR_STATE, // IllegalMonitorStateException
 135     OM_INTERRUPTED,           // Thread.interrupt()
 136     OM_TIMED_OUT              // Object.wait() timed out
 137   };
 138 
 139  private:
 140   friend class ObjectMonitorHandle;
 141   friend class ObjectSynchronizer;
 142   friend class ObjectWaiter;
 143   friend class VMStructs;
 144   JVMCI_ONLY(friend class JVMCIVMStructs;)
 145 
 146   // The sync code expects the header field to be at offset zero (0).
 147   // Enforced by the assert() in header_addr().
 148   volatile markWord _header;        // displaced object header word - mark
 149   void* volatile _object;           // backward object pointer - strong root
 150  public:
 151   ObjectMonitor* _next_om;          // Next ObjectMonitor* linkage
 152  private:
 153   // Separate _header and _owner on different cache lines since both can
 154   // have busy multi-threaded access. _header and _object are set at
 155   // initial inflation and _object doesn't change until deflation so
 156   // _object is a good choice to share the cache line with _header.
 157   // _next_om shares _header's cache line for pre-monitor list historical
 158   // reasons. _next_om only changes if the next ObjectMonitor is deflated.
 159   DEFINE_PAD_MINUS_SIZE(0, DEFAULT_CACHE_LINE_SIZE,
 160                         sizeof(volatile markWord) + sizeof(void* volatile) +
 161                         sizeof(ObjectMonitor *));
 162   // Used by async deflation as a marker in the _owner field:
 163   #define DEFLATER_MARKER reinterpret_cast<void*>(-1)
 164  protected:                         // protected for JvmtiRawMonitor
 165   void* volatile _owner;            // pointer to owning thread OR BasicLock
 166  private:
 167   volatile jlong _previous_owner_tid;  // thread id of the previous owner of the monitor
 168  protected:                         // protected for JvmtiRawMonitor
 169   volatile intptr_t _recursions;    // recursion count, 0 for first entry
 170   ObjectWaiter* volatile _EntryList;  // Threads blocked on entry or reentry.
 171                                       // The list is actually composed of WaitNodes,
 172                                       // acting as proxies for Threads.
 173  private:
 174   ObjectWaiter* volatile _cxq;      // LL of recently-arrived threads blocked on entry.
 175   Thread* volatile _succ;           // Heir presumptive thread - used for futile wakeup throttling
 176   Thread* volatile _Responsible;
 177 
 178   volatile int _Spinner;            // for exit->spinner handoff optimization
 179   volatile int _SpinDuration;
 180 
 181   volatile jint  _contentions;      // Number of active contentions in enter(). It is used by is_busy()
 182                                     // along with other fields to determine if an ObjectMonitor can be
 183                                     // deflated. See ObjectSynchronizer::deflate_monitor() and
 184                                     // ObjectSynchronizer::deflate_monitor_using_JT().
 185  protected:
 186   ObjectWaiter* volatile _WaitSet;  // LL of threads wait()ing on the monitor
 187   volatile jint  _waiters;          // number of waiting threads
 188  private:
 189   volatile int _WaitSetLock;        // protects Wait Queue - simple spinlock
 190   volatile jint _ref_count;         // ref count for ObjectMonitor* and used by the async deflation
 191                                     // protocol. See ObjectSynchronizer::deflate_monitor_using_JT().
 192   typedef enum {
 193     Free = 0,  // Free must be 0 for monitor to be free after memset(..,0,..).
 194     New,
 195     Old
 196   } AllocationState;
 197   AllocationState _allocation_state;
 198 
 199  public:
 200   static void Initialize();
 201 
 202   // Only perform a PerfData operation if the PerfData object has been
 203   // allocated and if the PerfDataManager has not freed the PerfData
 204   // objects which can happen at normal VM shutdown.
 205   //
 206   #define OM_PERFDATA_OP(f, op_str)              \
 207     do {                                         \
 208       if (ObjectMonitor::_sync_ ## f != NULL &&  \
 209           PerfDataManager::has_PerfData()) {     \
 210         ObjectMonitor::_sync_ ## f->op_str;      \
 211       }                                          \
 212     } while (0)
 213 
 214   static PerfCounter * _sync_ContendedLockAttempts;
 215   static PerfCounter * _sync_FutileWakeups;
 216   static PerfCounter * _sync_Parks;
 217   static PerfCounter * _sync_Notifications;


 239   // ObjectMonitor references can be ORed with markWord::monitor_value
 240   // as part of the ObjectMonitor tagging mechanism. When we combine an
 241   // ObjectMonitor reference with an offset, we need to remove the tag
 242   // value in order to generate the proper address.
 243   //
 244   // We can either adjust the ObjectMonitor reference and then add the
 245   // offset or we can adjust the offset that is added to the ObjectMonitor
 246   // reference. The latter avoids an AGI (Address Generation Interlock)
 247   // stall so the helper macro adjusts the offset value that is returned
 248   // to the ObjectMonitor reference manipulation code:
 249   //
 250   #define OM_OFFSET_NO_MONITOR_VALUE_TAG(f) \
 251     ((ObjectMonitor::f ## _offset_in_bytes()) - markWord::monitor_value)
 252 
 253   markWord           header() const;
 254   volatile markWord* header_addr();
 255   void               set_header(markWord hdr);
 256 
 257   intptr_t is_busy() const {
 258     // TODO-FIXME: assert _owner == null implies _recursions = 0
 259     // We do not include _ref_count in the is_busy() check because
 260     // _ref_count is for indicating that the ObjectMonitor* is in
 261     // use which is orthogonal to whether the ObjectMonitor itself
 262     // is in use for a locking operation.
 263     intptr_t ret_code = _contentions | _waiters | intptr_t(_cxq) | intptr_t(_EntryList);
 264     if (!AsyncDeflateIdleMonitors) {
 265       ret_code |= intptr_t(_owner);
 266     } else {
 267       if (_owner != DEFLATER_MARKER) {
 268         ret_code |= intptr_t(_owner);
 269       }
 270     }
 271     return ret_code;
 272   }
 273   const char* is_busy_to_string(stringStream* ss);
 274 
 275   intptr_t  is_entered(Thread* current) const;
 276 
 277   void*     owner() const;  // Returns NULL if DEFLATER_MARKER is observed.
 278   // Returns true if owner field == DEFLATER_MARKER and false otherwise.
 279   bool      owner_is_DEFLATER_MARKER();
 280   void      set_owner(void* owner);
 281 
 282   jint      waiters() const;
 283 
 284   jint      contentions() const;
 285   intptr_t  recursions() const                                         { return _recursions; }
 286 
 287   // JVM/TI GetObjectMonitorUsage() needs this:
 288   ObjectWaiter* first_waiter()                                         { return _WaitSet; }
 289   ObjectWaiter* next_waiter(ObjectWaiter* o)                           { return o->_next; }
 290   Thread* thread_of_waiter(ObjectWaiter* o)                            { return o->_thread; }
 291 
 292  protected:
 293   // We don't typically expect or want the ctors or dtors to run.
 294   // normal ObjectMonitors are type-stable and immortal.
 295   ObjectMonitor() { ::memset((void*)this, 0, sizeof(*this)); }
 296 
 297   ~ObjectMonitor() {
 298     // TODO: Add asserts ...
 299     // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0


 304   void Recycle() {
 305     // TODO: add stronger asserts ...
 306     // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0
 307     // _contentions == 0 EntryList  == NULL
 308     // _recursions == 0 _WaitSet == NULL
 309     DEBUG_ONLY(stringStream ss;)
 310     assert((is_busy() | _recursions) == 0, "freeing in-use monitor: %s, "
 311            "recursions=" INTPTR_FORMAT, is_busy_to_string(&ss), _recursions);
 312     _succ          = NULL;
 313     _EntryList     = NULL;
 314     _cxq           = NULL;
 315     _WaitSet       = NULL;
 316     _recursions    = 0;
 317   }
 318 
 319  public:
 320 
 321   void*     object() const;
 322   void*     object_addr();
 323   void      set_object(void* obj);
 324   void      set_allocation_state(AllocationState s);
 325   AllocationState allocation_state() const;
 326   bool      is_free() const;
 327   bool      is_active() const;
 328   bool      is_old() const;
 329   bool      is_new() const;
 330   void      dec_ref_count();
 331   void      inc_ref_count();
 332   jint      ref_count() const;
 333 
 334   // Returns true if the specified thread owns the ObjectMonitor. Otherwise
 335   // returns false and throws IllegalMonitorStateException (IMSE).
 336   bool      check_owner(Thread* THREAD);
 337   void      clear();
 338   void      clear_using_JT();
 339 
 340   void      enter(TRAPS);
 341   void      exit(bool not_suspended, TRAPS);
 342   void      wait(jlong millis, bool interruptable, TRAPS);
 343   void      notify(TRAPS);
 344   void      notifyAll(TRAPS);
 345 
 346   void      print() const;
 347   void      print_on(outputStream* st) const;
 348 
 349 // Use the following at your own risk
 350   intptr_t  complete_exit(TRAPS);
 351   void      reenter(intptr_t recursions, TRAPS);
 352 
 353  private:
 354   void      AddWaiter(ObjectWaiter* waiter);
 355   void      INotify(Thread* self);
 356   ObjectWaiter* DequeueWaiter();
 357   void      DequeueSpecificWaiter(ObjectWaiter* waiter);
 358   void      EnterI(TRAPS);
 359   void      ReenterI(Thread* self, ObjectWaiter* self_node);
 360   void      UnlinkAfterAcquire(Thread* self, ObjectWaiter* self_node);
 361   int       TryLock(Thread* self);
 362   int       NotRunnable(Thread* self, Thread* Owner);
 363   int       TrySpin(Thread* self);
 364   void      ExitEpilog(Thread* self, ObjectWaiter* Wakee);
 365   bool      ExitSuspendEquivalent(JavaThread* self);
 366   void      install_displaced_markword_in_object(const oop obj);
 367 };
 368 
 369 // A helper object for managing an ObjectMonitor*'s ref_count. There
 370 // are special safety considerations when async deflation is used.
 371 class ObjectMonitorHandle : public StackObj {
 372  private:
 373   ObjectMonitor* _om_ptr;
 374  public:
 375   ObjectMonitorHandle() { _om_ptr = NULL; }
 376   ~ObjectMonitorHandle();
 377 
 378   ObjectMonitor* om_ptr() const { return _om_ptr; }
 379   // Save the ObjectMonitor* associated with the specified markWord and
 380   // increment the ref_count.
 381   bool save_om_ptr(oop object, markWord mark);
 382 
 383   // For internal used by ObjectSynchronizer::monitors_iterate().
 384   ObjectMonitorHandle(ObjectMonitor* _om_ptr);
 385   // For internal use by ObjectSynchronizer::inflate().
 386   void set_om_ptr(ObjectMonitor* om_ptr);
 387 };
 388 
 389 // Macro to use guarantee() for more strict AsyncDeflateIdleMonitors
 390 // checks and assert() otherwise.
 391 #define ADIM_guarantee(p, ...)       \
 392   do {                               \
 393     if (AsyncDeflateIdleMonitors) {  \
 394       guarantee(p, __VA_ARGS__);     \
 395     } else {                         \
 396       assert(p, __VA_ARGS__);        \
 397     }                                \
 398   } while (0)
 399 
 400 #endif // SHARE_RUNTIME_OBJECTMONITOR_HPP
< prev index next >