< prev index next >

src/hotspot/share/runtime/synchronizer.hpp

Print this page
rev 56635 : 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; merge with 8230876.patch; merge with jdk-14+15; merge with jdk-14+18.
rev 56637 : Add OM_CACHE_LINE_SIZE so that ObjectMonitor cache line sizes can be experimented with independently of DEFAULT_CACHE_LINE_SIZE; for SPARC and X64 configs that use 128 for DEFAULT_CACHE_LINE_SIZE, we are experimenting with 64; move _previous_owner_tid and _allocation_state fields to share the cache line with ObjectMonitor::_header; put ObjectMonitor::_ref_count on its own cache line after _owner; add 'int* count_p' parameter to deflate_monitor_list() and deflate_monitor_list_using_JT() and push counter updates down to where the ObjectMonitors are actually removed from the in-use lists; monitors_iterate() async deflation check should use negative ref_count; add 'JavaThread* target' param to deflate_per_thread_idle_monitors_using_JT() add deflate_common_idle_monitors_using_JT() to make it clear which JavaThread* is the target of the work and which is the calling JavaThread* (self); g_free_list, g_om_in_use_list and g_om_in_use_count are now static to synchronizer.cpp (reduce scope); add more diagnostic info to some assert()'s; minor code cleanups and code motion; save_om_ptr() should detect a race with a deflating thread that is bailing out and cause a retry when the ref_count field is not positive; merge with jdk-14+11; add special GC support for TestHumongousClassLoader.java; merge with 8230184.patch; merge with jdk-14+14; merge with jdk-14+18.
rev 56638 : Merge the remainder of the lock-free monitor list changes from v2.06 with v2.06a and v2.06b after running the changes through the edit scripts; merge pieces from dcubed.monitor_deflate_conc.v2.06d in dcubed.monitor_deflate_conc.v2.06[ac]; merge pieces from dcubed.monitor_deflate_conc.v2.06e into dcubed.monitor_deflate_conc.v2.06c; merge with jdk-14+11; test work around for test/jdk/tools/jlink/multireleasejar/JLinkMultiReleaseJarTest.java should not been needed anymore; merge with jdk-14+18.
rev 56639 : loosen a couple more counter checks due to races observed in testing; simplify om_release() extraction of mid since list head or cur_mid_in_use is marked; simplify deflate_monitor_list() extraction of mid since there are no parallel deleters due to the safepoint; simplify deflate_monitor_list_using_JT() extraction of mid since list head or cur_mid_in_use is marked; prepend_block_to_lists() - simplify based on David H's comments; does not need load_acquire() or release_store() because of the cmpxchg(); prepend_to_common() - simplify to use mark_next_loop() for m and use mark_list_head() and release_store() for the non-empty list case; add more debugging for "Non-balanced monitor enter/exit" failure mode; fix race in inflate() in the "CASE: neutral" code path; install_displaced_markword_in_object() does not need to clear the header field since that is handled when the ObjectMonitor is moved from the global free list; LSuccess should clear boxReg to set ICC.ZF=1 to avoid depending on existing boxReg contents; update fast_unlock() to detect when object no longer refers to the same ObjectMonitor and take fast path exit instead; clarify fast_lock() code where we detect when object no longer refers to the same ObjectMonitor; add/update comments for movptr() calls where we move a literal into an Address; remove set_owner(); refactor setting of owner field into set_owner_from(2 versions), set_owner_from_BasicLock(), and try_set_owner_from(); the new functions include monitorinflation+owner logging; extract debug code from v2.06 and v2.07 and move to v2.07.debug; change 'jccb' -> 'jcc' and 'jmpb' -> 'jmp' as needed; checkpoint initial version of MacroAssembler::inc_om_ref_count(); update LP64 MacroAssembler::fast_lock() and fast_unlock() to use inc_om_ref_count(); fast_lock() return flag setting logic can use 'testptr(tmpReg, tmpReg)' instead of 'cmpptr(tmpReg, 0)' since that's more efficient; fast_unlock() LSuccess return flag setting logic can use 'testl (boxReg, 0)' instead of 'xorptr(boxReg, boxReg)' since that's more efficient; cleanup "fast-path" vs "fast path" and "slow-path" vs "slow path"; update MacroAssembler::rtm_inflated_locking() to use inc_om_ref_count(); update MacroAssembler::fast_lock() to preserve the flags before decrementing ref_count and restore the flags afterwards; this is more clean than depending on the contents of rax/tmpReg; coleenp CR - refactor async monitor deflation work from ServiceThread::service_thread_entry() to ObjectSynchronizer::deflate_idle_monitors_using_JT(); rehn,eosterlund CR - add support for HandshakeAfterDeflateIdleMonitors for platforms that don't have ObjectMonitor ref_count support implemented in C2 fast_lock() and fast_unlock().


  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_RUNTIME_SYNCHRONIZER_HPP
  26 #define SHARE_RUNTIME_SYNCHRONIZER_HPP
  27 
  28 #include "memory/padded.hpp"
  29 #include "oops/markWord.hpp"
  30 #include "runtime/basicLock.hpp"
  31 #include "runtime/handles.hpp"
  32 #include "runtime/perfData.hpp"
  33 
  34 class ObjectMonitor;

  35 class ThreadsList;
  36 
  37 typedef PaddedEnd<ObjectMonitor, DEFAULT_CACHE_LINE_SIZE> PaddedObjectMonitor;






  38 
  39 struct DeflateMonitorCounters {
  40   int n_in_use;              // currently associated with objects
  41   int n_in_circulation;      // extant
  42   int n_scavenged;           // reclaimed (global and per-thread)
  43   int per_thread_scavenged;  // per-thread scavenge total
  44   double per_thread_times;   // per-thread scavenge times
  45 };
  46 
  47 class ObjectSynchronizer : AllStatic {
  48   friend class VMStructs;
  49  public:
  50   typedef enum {
  51     owner_self,
  52     owner_none,
  53     owner_other
  54   } LockOwnership;
  55 
  56   typedef enum {
  57     inflate_cause_vm_internal = 0,
  58     inflate_cause_monitor_enter = 1,
  59     inflate_cause_wait = 2,
  60     inflate_cause_notify = 3,
  61     inflate_cause_hash_code = 4,
  62     inflate_cause_jni_enter = 5,
  63     inflate_cause_jni_exit = 6,


  79   // Handle all interpreter, compiler and jni cases
  80   static int  wait(Handle obj, jlong millis, TRAPS);
  81   static void notify(Handle obj, TRAPS);
  82   static void notifyall(Handle obj, TRAPS);
  83 
  84   static bool quick_notify(oopDesc* obj, Thread* self, bool All);
  85   static bool quick_enter(oop obj, Thread* self, BasicLock* Lock);
  86 
  87   // Special internal-use-only method for use by JVM infrastructure
  88   // that needs to wait() on a java-level object but that can't risk
  89   // throwing unexpected InterruptedExecutionExceptions.
  90   static void wait_uninterruptibly(Handle obj, jlong Millis, Thread* THREAD);
  91 
  92   // used by classloading to free classloader object lock,
  93   // wait on an internal lock, and reclaim original lock
  94   // with original recursion count
  95   static intptr_t complete_exit(Handle obj, TRAPS);
  96   static void reenter (Handle obj, intptr_t recursion, TRAPS);
  97 
  98   // thread-specific and global ObjectMonitor free list accessors
  99   static ObjectMonitor* om_alloc(Thread* self);
 100   static void om_release(Thread* self, ObjectMonitor* m,
 101                          bool FromPerThreadAlloc);
 102   static void om_flush(Thread* self);
 103 
 104   // Inflate light weight monitor to heavy weight monitor
 105   static ObjectMonitor* inflate(Thread* self, oop obj, const InflateCause cause);

 106   // This version is only for internal use
 107   static void inflate_helper(oop obj);
 108   static const char* inflate_cause_name(const InflateCause cause);
 109 
 110   // Returns the identity hash value for an oop
 111   // NOTE: It may cause monitor inflation
 112   static intptr_t identity_hash_value_for(Handle obj);
 113   static intptr_t FastHashCode(Thread* self, oop obj);
 114 
 115   // java.lang.Thread support
 116   static bool current_thread_holds_lock(JavaThread* thread, Handle h_obj);
 117   static LockOwnership query_lock_ownership(JavaThread* self, Handle h_obj);
 118 
 119   static JavaThread* get_lock_owner(ThreadsList * t_list, Handle h_obj);
 120 
 121   // JNI detach support
 122   static void release_monitors_owned_by_thread(TRAPS);
 123   static void monitors_iterate(MonitorClosure* m);
 124 
 125   // GC: we current use aggressive monitor deflation policy
 126   // Basically we deflate all monitors that are not busy.
 127   // An adaptive profile-based deflation policy could be used if needed
 128   static void deflate_idle_monitors(DeflateMonitorCounters* counters);




 129   static void deflate_thread_local_monitors(Thread* thread, DeflateMonitorCounters* counters);
 130   static void prepare_deflate_idle_monitors(DeflateMonitorCounters* counters);
 131   static void finish_deflate_idle_monitors(DeflateMonitorCounters* counters);
 132 
 133   // For a given monitor list: global or per-thread, deflate idle monitors
 134   static int deflate_monitor_list(ObjectMonitor** list_p,

 135                                   ObjectMonitor** free_head_p,
 136                                   ObjectMonitor** free_tail_p);







 137   static bool deflate_monitor(ObjectMonitor* mid, oop obj,
 138                               ObjectMonitor** free_head_p,
 139                               ObjectMonitor** free_tail_p);
 140   static bool is_cleanup_needed();









 141   static void oops_do(OopClosure* f);
 142   // Process oops in thread local used monitors
 143   static void thread_local_used_oops_do(Thread* thread, OopClosure* f);
 144 
 145   // debugging
 146   static void audit_and_print_stats(bool on_exit);
 147   static void chk_free_entry(JavaThread* jt, ObjectMonitor* n,
 148                              outputStream * out, int *error_cnt_p);
 149   static void chk_global_free_list_and_count(outputStream * out,
 150                                              int *error_cnt_p);


 151   static void chk_global_in_use_list_and_count(outputStream * out,
 152                                                int *error_cnt_p);
 153   static void chk_in_use_entry(JavaThread* jt, ObjectMonitor* n,
 154                                outputStream * out, int *error_cnt_p);
 155   static void chk_per_thread_in_use_list_and_count(JavaThread *jt,
 156                                                    outputStream * out,
 157                                                    int *error_cnt_p);
 158   static void chk_per_thread_free_list_and_count(JavaThread *jt,
 159                                                  outputStream * out,
 160                                                  int *error_cnt_p);
 161   static void log_in_use_monitor_details(outputStream * out, bool on_exit);
 162   static int  log_monitor_list_counts(outputStream * out);
 163   static int  verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0;
 164 


 165  private:
 166   friend class SynchronizerTest;
 167 
 168   enum { _BLOCKSIZE = 128 };
 169   // global list of blocks of monitors
 170   static PaddedObjectMonitor* volatile g_block_list;
 171   // global monitor free list
 172   static ObjectMonitor* volatile g_free_list;
 173   // global monitor in-use list, for moribund threads,
 174   // monitors they inflated need to be scanned for deflation
 175   static ObjectMonitor* volatile g_om_in_use_list;
 176   // count of entries in g_om_in_use_list
 177   static int g_om_in_use_count;
 178 
 179   // Process oops in all global used monitors (i.e. moribund thread's monitors)
 180   static void global_used_oops_do(OopClosure* f);
 181   // Process oops in monitors on the given list
 182   static void list_oops_do(ObjectMonitor* list, OopClosure* f);
 183 
 184   // Support for SynchronizerTest access to GVars fields:
 185   static u_char* get_gvars_addr();
 186   static u_char* get_gvars_hc_sequence_addr();
 187   static size_t get_gvars_size();
 188   static u_char* get_gvars_stw_random_addr();
 189 };
 190 
 191 // ObjectLocker enforces balanced locking and can never throw an
 192 // IllegalMonitorStateException. However, a pending exception may
 193 // have to pass through, and we must also be able to deal with
 194 // asynchronous exceptions. The caller is responsible for checking
 195 // the thread's pending exception if needed.
 196 class ObjectLocker : public StackObj {
 197  private:
 198   Thread*   _thread;
 199   Handle    _obj;
 200   BasicLock _lock;
 201   bool      _dolock;   // default true
 202  public:


  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_RUNTIME_SYNCHRONIZER_HPP
  26 #define SHARE_RUNTIME_SYNCHRONIZER_HPP
  27 
  28 #include "memory/padded.hpp"
  29 #include "oops/markWord.hpp"
  30 #include "runtime/basicLock.hpp"
  31 #include "runtime/handles.hpp"
  32 #include "runtime/perfData.hpp"
  33 
  34 class ObjectMonitor;
  35 class ObjectMonitorHandle;
  36 class ThreadsList;
  37 
  38 #ifndef OM_CACHE_LINE_SIZE
  39 // Use DEFAULT_CACHE_LINE_SIZE if not already specified for
  40 // the current build platform.
  41 #define OM_CACHE_LINE_SIZE DEFAULT_CACHE_LINE_SIZE
  42 #endif
  43 
  44 typedef PaddedEnd<ObjectMonitor, OM_CACHE_LINE_SIZE> PaddedObjectMonitor;
  45 
  46 struct DeflateMonitorCounters {
  47   volatile int n_in_use;              // currently associated with objects
  48   volatile int n_in_circulation;      // extant
  49   volatile int n_scavenged;           // reclaimed (global and per-thread)
  50   volatile int per_thread_scavenged;  // per-thread scavenge total
  51            double per_thread_times;   // per-thread scavenge times
  52 };
  53 
  54 class ObjectSynchronizer : AllStatic {
  55   friend class VMStructs;
  56  public:
  57   typedef enum {
  58     owner_self,
  59     owner_none,
  60     owner_other
  61   } LockOwnership;
  62 
  63   typedef enum {
  64     inflate_cause_vm_internal = 0,
  65     inflate_cause_monitor_enter = 1,
  66     inflate_cause_wait = 2,
  67     inflate_cause_notify = 3,
  68     inflate_cause_hash_code = 4,
  69     inflate_cause_jni_enter = 5,
  70     inflate_cause_jni_exit = 6,


  86   // Handle all interpreter, compiler and jni cases
  87   static int  wait(Handle obj, jlong millis, TRAPS);
  88   static void notify(Handle obj, TRAPS);
  89   static void notifyall(Handle obj, TRAPS);
  90 
  91   static bool quick_notify(oopDesc* obj, Thread* self, bool All);
  92   static bool quick_enter(oop obj, Thread* self, BasicLock* Lock);
  93 
  94   // Special internal-use-only method for use by JVM infrastructure
  95   // that needs to wait() on a java-level object but that can't risk
  96   // throwing unexpected InterruptedExecutionExceptions.
  97   static void wait_uninterruptibly(Handle obj, jlong Millis, Thread* THREAD);
  98 
  99   // used by classloading to free classloader object lock,
 100   // wait on an internal lock, and reclaim original lock
 101   // with original recursion count
 102   static intptr_t complete_exit(Handle obj, TRAPS);
 103   static void reenter (Handle obj, intptr_t recursion, TRAPS);
 104 
 105   // thread-specific and global ObjectMonitor free list accessors
 106   static ObjectMonitor* om_alloc(Thread* self, const InflateCause cause);
 107   static void om_release(Thread* self, ObjectMonitor* m,
 108                          bool FromPerThreadAlloc);
 109   static void om_flush(Thread* self);
 110 
 111   // Inflate light weight monitor to heavy weight monitor
 112   static void inflate(ObjectMonitorHandle* omh_p, Thread* self, oop obj,
 113                       const InflateCause cause);
 114   // This version is only for internal use
 115   static void inflate_helper(ObjectMonitorHandle* omh_p, oop obj);
 116   static const char* inflate_cause_name(const InflateCause cause);
 117 
 118   // Returns the identity hash value for an oop
 119   // NOTE: It may cause monitor inflation
 120   static intptr_t identity_hash_value_for(Handle obj);
 121   static intptr_t FastHashCode(Thread* self, oop obj);
 122 
 123   // java.lang.Thread support
 124   static bool current_thread_holds_lock(JavaThread* thread, Handle h_obj);
 125   static LockOwnership query_lock_ownership(JavaThread* self, Handle h_obj);
 126 
 127   static JavaThread* get_lock_owner(ThreadsList * t_list, Handle h_obj);
 128 
 129   // JNI detach support
 130   static void release_monitors_owned_by_thread(TRAPS);
 131   static void monitors_iterate(MonitorClosure* m);
 132 
 133   // GC: we current use aggressive monitor deflation policy
 134   // Basically we deflate all monitors that are not busy.
 135   // An adaptive profile-based deflation policy could be used if needed
 136   static void deflate_idle_monitors(DeflateMonitorCounters* counters);
 137   static void deflate_idle_monitors_using_JT();
 138   static void deflate_global_idle_monitors_using_JT();
 139   static void deflate_per_thread_idle_monitors_using_JT(JavaThread* target);
 140   static void deflate_common_idle_monitors_using_JT(bool is_global, JavaThread* target);
 141   static void deflate_thread_local_monitors(Thread* thread, DeflateMonitorCounters* counters);
 142   static void prepare_deflate_idle_monitors(DeflateMonitorCounters* counters);
 143   static void finish_deflate_idle_monitors(DeflateMonitorCounters* counters);
 144 
 145   // For a given monitor list: global or per-thread, deflate idle monitors
 146   static int deflate_monitor_list(ObjectMonitor* volatile * list_p,
 147                                   int volatile * count_p,
 148                                   ObjectMonitor** free_head_p,
 149                                   ObjectMonitor** free_tail_p);
 150   // For a given in-use monitor list: global or per-thread, deflate idle
 151   // monitors using a JavaThread.
 152   static int deflate_monitor_list_using_JT(ObjectMonitor* volatile * list_p,
 153                                            int volatile * count_p,
 154                                            ObjectMonitor** free_head_p,
 155                                            ObjectMonitor** free_tail_p,
 156                                            ObjectMonitor** saved_mid_in_use_p);
 157   static bool deflate_monitor(ObjectMonitor* mid, oop obj,
 158                               ObjectMonitor** free_head_p,
 159                               ObjectMonitor** free_tail_p);
 160   static bool deflate_monitor_using_JT(ObjectMonitor* mid,
 161                                        ObjectMonitor** free_head_p,
 162                                        ObjectMonitor** free_tail_p);
 163   static bool is_async_deflation_needed();
 164   static bool is_safepoint_deflation_needed();
 165   static bool is_async_deflation_requested() { return _is_async_deflation_requested; }
 166   static bool is_special_deflation_requested() { return _is_special_deflation_requested; }
 167   static void set_is_async_deflation_requested(bool new_value) { _is_async_deflation_requested = new_value; }
 168   static void set_is_special_deflation_requested(bool new_value) { _is_special_deflation_requested = new_value; }
 169   static jlong time_since_last_async_deflation_ms();
 170   static void oops_do(OopClosure* f);
 171   // Process oops in thread local used monitors
 172   static void thread_local_used_oops_do(Thread* thread, OopClosure* f);
 173 
 174   // debugging
 175   static void audit_and_print_stats(bool on_exit);
 176   static void chk_free_entry(JavaThread* jt, ObjectMonitor* n,
 177                              outputStream * out, int *error_cnt_p);
 178   static void chk_global_free_list_and_count(outputStream * out,
 179                                              int *error_cnt_p);
 180   static void chk_global_wait_list_and_count(outputStream * out,
 181                                              int *error_cnt_p);
 182   static void chk_global_in_use_list_and_count(outputStream * out,
 183                                                int *error_cnt_p);
 184   static void chk_in_use_entry(JavaThread* jt, ObjectMonitor* n,
 185                                outputStream * out, int *error_cnt_p);
 186   static void chk_per_thread_in_use_list_and_count(JavaThread *jt,
 187                                                    outputStream * out,
 188                                                    int *error_cnt_p);
 189   static void chk_per_thread_free_list_and_count(JavaThread *jt,
 190                                                  outputStream * out,
 191                                                  int *error_cnt_p);
 192   static void log_in_use_monitor_details(outputStream * out);
 193   static int  log_monitor_list_counts(outputStream * out);
 194   static int  verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0;
 195 
 196   static void do_safepoint_work(DeflateMonitorCounters* counters);
 197 
 198  private:
 199   friend class SynchronizerTest;
 200 
 201   enum { _BLOCKSIZE = 128 };
 202   // global list of blocks of monitors
 203   static PaddedObjectMonitor* volatile g_block_list;
 204   static volatile bool _is_async_deflation_requested;
 205   static volatile bool _is_special_deflation_requested;
 206   static jlong         _last_async_deflation_time_ns;
 207 
 208   // Function to prepend new blocks to the appropriate lists:
 209   static void prepend_block_to_lists(PaddedObjectMonitor* new_blk);

 210 
 211   // Process oops in all global used monitors (i.e. moribund thread's monitors)
 212   static void global_used_oops_do(OopClosure* f);
 213   // Process oops in monitors on the given list
 214   static void list_oops_do(ObjectMonitor* list, int count, OopClosure* f);
 215 
 216   // Support for SynchronizerTest access to GVars fields:
 217   static u_char* get_gvars_addr();
 218   static u_char* get_gvars_hc_sequence_addr();
 219   static size_t get_gvars_size();
 220   static u_char* get_gvars_stw_random_addr();
 221 };
 222 
 223 // ObjectLocker enforces balanced locking and can never throw an
 224 // IllegalMonitorStateException. However, a pending exception may
 225 // have to pass through, and we must also be able to deal with
 226 // asynchronous exceptions. The caller is responsible for checking
 227 // the thread's pending exception if needed.
 228 class ObjectLocker : public StackObj {
 229  private:
 230   Thread*   _thread;
 231   Handle    _obj;
 232   BasicLock _lock;
 233   bool      _dolock;   // default true
 234  public:
< prev index next >