--- old/src/hotspot/share/runtime/objectMonitor.hpp 2019-12-11 14:52:16.000000000 -0500 +++ new/src/hotspot/share/runtime/objectMonitor.hpp 2019-12-11 14:52:16.000000000 -0500 @@ -120,7 +120,14 @@ // intptr_t. There's no reason to use a 64-bit type for this field // in a 64-bit JVM. +#ifndef OM_CACHE_LINE_SIZE +// Use DEFAULT_CACHE_LINE_SIZE if not already specified for +// the current build platform. +#define OM_CACHE_LINE_SIZE DEFAULT_CACHE_LINE_SIZE +#endif + class ObjectMonitor { + friend class ObjectMonitorHandle; friend class ObjectSynchronizer; friend class ObjectWaiter; friend class VMStructs; @@ -130,20 +137,37 @@ // Enforced by the assert() in header_addr(). volatile markWord _header; // displaced object header word - mark void* volatile _object; // backward object pointer - strong root - public: - ObjectMonitor* _next_om; // Next ObjectMonitor* linkage - private: + typedef enum { + Free = 0, // Free must be 0 for monitor to be free after memset(..,0,..). + New, + Old + } AllocationState; + AllocationState _allocation_state; // Separate _header and _owner on different cache lines since both can - // have busy multi-threaded access. _header and _object are set at - // initial inflation and _object doesn't change until deflation so - // _object is a good choice to share the cache line with _header. - // _next_om shares _header's cache line for pre-monitor list historical - // reasons. _next_om only changes if the next ObjectMonitor is deflated. - DEFINE_PAD_MINUS_SIZE(0, DEFAULT_CACHE_LINE_SIZE, - sizeof(volatile markWord) + sizeof(void* volatile) + - sizeof(ObjectMonitor *)); + // have busy multi-threaded access. _header, _object and _allocation_state + // are set at initial inflation. _object and _allocation_state don't + // change until deflation so _object and _allocation_state are good + // choices to share the cache line with _header. + DEFINE_PAD_MINUS_SIZE(0, OM_CACHE_LINE_SIZE, sizeof(volatile markWord) + + sizeof(void* volatile) + sizeof(AllocationState)); + // Used by async deflation as a marker in the _owner field: + #define DEFLATER_MARKER reinterpret_cast(-1) void* volatile _owner; // pointer to owning thread OR BasicLock volatile jlong _previous_owner_tid; // thread id of the previous owner of the monitor + // Separate _owner and _ref_count on different cache lines since both + // can have busy multi-threaded access. _previous_owner_tid is only + // changed by ObjectMonitor::exit() so it is a good choice to share the + // cache line with _owner. + DEFINE_PAD_MINUS_SIZE(1, OM_CACHE_LINE_SIZE, sizeof(void* volatile) + + sizeof(volatile jlong)); + jint _ref_count; // ref count for ObjectMonitor* and used by the async deflation + // protocol. See ObjectSynchronizer::deflate_monitor_using_JT(). + // Separate _ref_count and _next_om on different cache lines since + // both can have busy multi-threaded access. + DEFINE_PAD_MINUS_SIZE(2, OM_CACHE_LINE_SIZE, sizeof(volatile jint)); + public: // for static synchronizer.cpp access: + ObjectMonitor* _next_om; // Next ObjectMonitor* linkage + private: volatile intx _recursions; // recursion count, 0 for first entry ObjectWaiter* volatile _EntryList; // Threads blocked on entry or reentry. // The list is actually composed of WaitNodes, @@ -158,7 +182,8 @@ volatile jint _contentions; // Number of active contentions in enter(). It is used by is_busy() // along with other fields to determine if an ObjectMonitor can be - // deflated. See ObjectSynchronizer::deflate_monitor(). + // deflated. See ObjectSynchronizer::deflate_monitor() and + // ObjectSynchronizer::deflate_monitor_using_JT(). protected: ObjectWaiter* volatile _WaitSet; // LL of threads wait()ing on the monitor volatile jint _waiters; // number of waiting threads @@ -200,6 +225,7 @@ static int header_offset_in_bytes() { return offset_of(ObjectMonitor, _header); } static int object_offset_in_bytes() { return offset_of(ObjectMonitor, _object); } static int owner_offset_in_bytes() { return offset_of(ObjectMonitor, _owner); } + static int ref_count_offset_in_bytes() { return offset_of(ObjectMonitor, _ref_count); } static int recursions_offset_in_bytes() { return offset_of(ObjectMonitor, _recursions); } static int cxq_offset_in_bytes() { return offset_of(ObjectMonitor, _cxq); } static int succ_offset_in_bytes() { return offset_of(ObjectMonitor, _succ); } @@ -225,14 +251,38 @@ intptr_t is_busy() const { // TODO-FIXME: assert _owner == null implies _recursions = 0 - return _contentions|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList); + // We do not include _ref_count in the is_busy() check because + // _ref_count is for indicating that the ObjectMonitor* is in + // use which is orthogonal to whether the ObjectMonitor itself + // is in use for a locking operation. + intptr_t ret_code = _contentions | _waiters | intptr_t(_cxq) | intptr_t(_EntryList); + if (!AsyncDeflateIdleMonitors) { + ret_code |= intptr_t(_owner); + } else { + if (_owner != DEFLATER_MARKER) { + ret_code |= intptr_t(_owner); + } + } + return ret_code; } const char* is_busy_to_string(stringStream* ss); intptr_t is_entered(Thread* current) const; - void* owner() const; - void set_owner(void* owner); + void* owner() const; // Returns NULL if DEFLATER_MARKER is observed. + // Returns true if owner field == DEFLATER_MARKER and false otherwise. + bool owner_is_DEFLATER_MARKER(); + // Clear _owner field; current value must match old_value. + void release_clear_owner_with_barrier(void* old_value, bool needs_fence); + // Simply set _owner field to new_value; current value must match old_value. + void simply_set_owner_from(void* new_value, void* old_value); + // Simply set _owner field to new_value; current value must match old_value1 or old_value2. + void simply_set_owner_from(void* new_value, void* old_value1, void* old_value2); + // Simply set _owner field to self; current value must match basic_lock_p. + void simply_set_owner_from_BasicLock(Thread* self, void* basic_lock_p); + // Try to set _owner field to new_value if the current value matches + // old_value. Otherwise, does not change the _owner field. + void* try_set_owner_from(void* new_value, void* old_value); jint waiters() const; @@ -261,7 +311,9 @@ // _cxq == 0 _succ == NULL _owner == NULL _waiters == 0 // _contentions == 0 EntryList == NULL // _recursions == 0 _WaitSet == NULL - DEBUG_ONLY(stringStream ss;) +#ifdef ASSERT + stringStream ss; +#endif assert((is_busy() | _recursions) == 0, "freeing in-use monitor: %s, " "recursions=" INTX_FORMAT, is_busy_to_string(&ss), _recursions); _succ = NULL; @@ -276,11 +328,20 @@ void* object() const; void* object_addr(); void set_object(void* obj); + void set_allocation_state(AllocationState s); + AllocationState allocation_state() const; + bool is_free() const; + bool is_old() const; + bool is_new() const; + void dec_ref_count(); + void inc_ref_count(); + jint ref_count() const; // Returns true if the specified thread owns the ObjectMonitor. Otherwise // returns false and throws IllegalMonitorStateException (IMSE). bool check_owner(Thread* THREAD); void clear(); + void clear_using_JT(); void enter(TRAPS); void exit(bool not_suspended, TRAPS); @@ -307,10 +368,44 @@ void ReenterI(Thread* self, ObjectWaiter* self_node); void UnlinkAfterAcquire(Thread* self, ObjectWaiter* self_node); int TryLock(Thread* self); - int NotRunnable(Thread* self, Thread * Owner); + int NotRunnable(Thread* self, Thread* Owner); int TrySpin(Thread* self); void ExitEpilog(Thread* self, ObjectWaiter* Wakee); bool ExitSuspendEquivalent(JavaThread* self); + void install_displaced_markword_in_object(const oop obj); +}; + +// A helper object for managing an ObjectMonitor*'s ref_count. There +// are special safety considerations when async deflation is used. +class ObjectMonitorHandle : public StackObj { + private: + ObjectMonitor* _om_ptr; + public: + ObjectMonitorHandle() { _om_ptr = NULL; } + ~ObjectMonitorHandle(); + + ObjectMonitor* om_ptr() const { return _om_ptr; } + // Save the ObjectMonitor* associated with the specified markWord and + // increment the ref_count. + bool save_om_ptr(oop object, markWord mark); + // Save the specified ObjectMonitor* if safe and increment the ref_count. + bool set_om_ptr_if_safe(ObjectMonitor* om_ptr); + // Unset the _om_ptr field and decrement the ref_count. + void unset_om_ptr(); + + // For internal use by ObjectSynchronizer::inflate(). + void set_om_ptr(ObjectMonitor* om_ptr); }; +// Macro to use guarantee() for more strict AsyncDeflateIdleMonitors +// checks and assert() otherwise. +#define ADIM_guarantee(p, ...) \ + do { \ + if (AsyncDeflateIdleMonitors) { \ + guarantee(p, __VA_ARGS__); \ + } else { \ + assert(p, __VA_ARGS__); \ + } \ + } while (0) + #endif // SHARE_RUNTIME_OBJECTMONITOR_HPP