1 /* 2 * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 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/javaThread.hpp" 33 #include "utilities/resourceHash.hpp" 34 35 template <typename T> class GrowableArray; 36 class LogStream; 37 class ObjectMonitor; 38 class ObjectMonitorDeflationSafepointer; 39 class ThreadsList; 40 41 class MonitorList { 42 friend class VMStructs; 43 44 private: 45 ObjectMonitor* volatile _head; 46 volatile size_t _count; 47 volatile size_t _max; 48 49 public: 50 void add(ObjectMonitor* monitor); 51 size_t unlink_deflated(size_t deflated_count, 52 GrowableArray<ObjectMonitor*>* unlinked_list, 53 ObjectMonitorDeflationSafepointer* safepointer); 54 size_t count() const; 55 size_t max() const; 56 57 class Iterator; 58 Iterator iterator() const; 59 }; 60 61 class MonitorList::Iterator { 62 ObjectMonitor* _current; 63 64 public: 65 Iterator(ObjectMonitor* head) : _current(head) {} 66 bool has_next() const { return _current != nullptr; } 67 ObjectMonitor* next(); 68 }; 69 70 class ObjectSynchronizer : AllStatic { 71 friend class VMStructs; 72 friend class ObjectMonitorDeflationLogging; 73 friend class WhiteBox; 74 75 public: 76 typedef enum { 77 inflate_cause_vm_internal = 0, 78 inflate_cause_monitor_enter = 1, 79 inflate_cause_wait = 2, 80 inflate_cause_notify = 3, 81 inflate_cause_hash_code = 4, 82 inflate_cause_jni_enter = 5, 83 inflate_cause_jni_exit = 6, 84 inflate_cause_nof = 7 // Number of causes 85 } InflateCause; 86 87 typedef enum { 88 NOT_ENABLED = 0, 89 FATAL_EXIT = 1, 90 LOG_WARNING = 2 91 } SyncDiagnosticOption; 92 93 // exit must be implemented non-blocking, since the compiler cannot easily handle 94 // deoptimization at monitor exit. Hence, it does not take a Handle argument. 95 96 // This is the "slow path" version of monitor enter and exit. 97 static inline void enter(Handle obj, BasicLock* lock, JavaThread* current); 98 static inline void exit(oop obj, BasicLock* lock, JavaThread* current); 99 100 // Used to enter a monitor for another thread. This requires that the 101 // locking_thread is suspended, and that entering on a potential 102 // inflated monitor may only contend with deflation. That is the obj being 103 // locked on is either already locked by the locking_thread or cannot 104 // escape the locking_thread. 105 static void enter_for(Handle obj, BasicLock* lock, JavaThread* locking_thread); 106 private: 107 // Shared implementation for enter and enter_for. Performs all but 108 // inflated monitor enter. 109 static bool enter_fast_impl(Handle obj, BasicLock* lock, JavaThread* locking_thread); 110 111 static bool quick_enter_legacy(oop obj, BasicLock* Lock, JavaThread* current); 112 static void enter_legacy(Handle obj, BasicLock* Lock, JavaThread* current); 113 static void exit_legacy(oop obj, BasicLock* lock, JavaThread* current); 114 public: 115 // Used only to handle jni locks or other unmatched monitor enter/exit 116 // Internally they will use heavy weight monitor. 117 static void jni_enter(Handle obj, JavaThread* current); 118 static void jni_exit(oop obj, TRAPS); 119 120 // Handle all interpreter, compiler and jni cases 121 static int wait(Handle obj, jlong millis, TRAPS); 122 static void notify(Handle obj, TRAPS); 123 static void notifyall(Handle obj, TRAPS); 124 125 static bool quick_notify(oopDesc* obj, JavaThread* current, bool All); 126 static inline bool quick_enter(oop obj, BasicLock* Lock, JavaThread* current); 127 128 // Special internal-use-only method for use by JVM infrastructure 129 // that needs to wait() on a java-level object but that can't risk 130 // throwing unexpected InterruptedExecutionExceptions. 131 static void waitUninterruptibly(Handle obj, jlong Millis, TRAPS); 132 133 // Inflate light weight monitor to heavy weight monitor 134 static ObjectMonitor* inflate(Thread* current, oop obj, const InflateCause cause); 135 // Used to inflate a monitor as if it was done from the thread JavaThread. 136 static ObjectMonitor* inflate_for(JavaThread* thread, oop obj, const InflateCause cause); 137 138 private: 139 // Shared implementation between the different LockingMode. 140 static ObjectMonitor* inflate_impl(JavaThread* locking_thread, oop obj, const InflateCause cause); 141 142 public: 143 // This version is only for internal use 144 static void inflate_helper(oop obj); 145 static const char* inflate_cause_name(const InflateCause cause); 146 147 inline static ObjectMonitor* read_monitor(markWord mark); 148 inline static ObjectMonitor* read_monitor(Thread* current, oop obj, markWord mark); 149 150 // Returns the identity hash value for an oop 151 // NOTE: It may cause monitor inflation 152 static intptr_t FastHashCode(Thread* current, oop obj); 153 154 // java.lang.Thread support 155 static bool current_thread_holds_lock(JavaThread* current, Handle h_obj); 156 157 static JavaThread* get_lock_owner(ThreadsList * t_list, Handle h_obj); 158 159 // JNI detach support 160 static void release_monitors_owned_by_thread(JavaThread* current); 161 162 // Iterate over all ObjectMonitors. 163 template <typename Function> 164 static void monitors_iterate(Function function); 165 166 // Iterate ObjectMonitors owned by any thread and where the owner `filter` 167 // returns true. 168 template <typename OwnerFilter> 169 static void owned_monitors_iterate_filtered(MonitorClosure* closure, OwnerFilter filter); 170 171 // Iterate ObjectMonitors where the owner is thread; this does NOT include 172 // ObjectMonitors where the owner is anonymous. 173 static void owned_monitors_iterate(MonitorClosure* m, JavaThread* thread); 174 175 // Iterate ObjectMonitors where the owner is vthread. 176 static void owned_monitors_iterate(MonitorClosure* m, oop vthread); 177 178 // Iterate ObjectMonitors owned by any thread. 179 static void owned_monitors_iterate(MonitorClosure* closure); 180 181 // Initialize the gInflationLocks 182 static void initialize(); 183 184 // We currently use aggressive monitor deflation policy; 185 // basically we try to deflate all monitors that are not busy. 186 static size_t deflate_idle_monitors(); 187 188 // Deflate idle monitors: 189 static size_t deflate_monitor_list(ObjectMonitorDeflationSafepointer* safepointer); 190 static size_t in_use_list_ceiling(); 191 static void dec_in_use_list_ceiling(); 192 static void inc_in_use_list_ceiling(); 193 static void set_in_use_list_ceiling(size_t new_value); 194 static bool is_async_deflation_needed(); 195 static bool is_async_deflation_requested() { return _is_async_deflation_requested; } 196 static bool is_final_audit() { return _is_final_audit; } 197 static void set_is_final_audit() { _is_final_audit = true; } 198 static jlong last_async_deflation_time_ns() { return _last_async_deflation_time_ns; } 199 static void request_deflate_idle_monitors(); 200 static bool request_deflate_idle_monitors_from_wb(); // for whitebox test support 201 static void set_is_async_deflation_requested(bool new_value) { _is_async_deflation_requested = new_value; } 202 static jlong time_since_last_async_deflation_ms(); 203 204 // debugging 205 static void audit_and_print_stats(outputStream* out, bool on_exit); 206 static void chk_in_use_list(outputStream* out, int* error_cnt_p); 207 static void chk_in_use_entry(ObjectMonitor* n, outputStream* out, 208 int* error_cnt_p); 209 static void do_final_audit_and_print_stats(); 210 static void log_in_use_monitor_details(outputStream* out, bool log_all); 211 212 private: 213 friend class SynchronizerTest; 214 friend class LightweightSynchronizer; 215 216 static MonitorList _in_use_list; 217 static volatile bool _is_async_deflation_requested; 218 static volatile bool _is_final_audit; 219 static jlong _last_async_deflation_time_ns; 220 221 // Support for SynchronizerTest access to GVars fields: 222 static u_char* get_gvars_addr(); 223 static u_char* get_gvars_hc_sequence_addr(); 224 static size_t get_gvars_size(); 225 static u_char* get_gvars_stw_random_addr(); 226 227 static void handle_sync_on_value_based_class(Handle obj, JavaThread* locking_thread); 228 }; 229 230 // ObjectLocker enforces balanced locking and can never throw an 231 // IllegalMonitorStateException. However, a pending exception may 232 // have to pass through, and we must also be able to deal with 233 // asynchronous exceptions. The caller is responsible for checking 234 // the thread's pending exception if needed. 235 // When using ObjectLocker the top native frames in the stack will 236 // not be seen in case we attempt preemption, since we start walking 237 // from the last Java anchor, so we disable it with NoPreemptMark. 238 class ObjectLocker : public StackObj { 239 private: 240 JavaThread* _thread; 241 Handle _obj; 242 BasicLock _lock; 243 NoPreemptMark _npm; 244 public: 245 ObjectLocker(Handle obj, JavaThread* current); 246 ~ObjectLocker(); 247 248 // Monitor behavior 249 void wait(TRAPS) { ObjectSynchronizer::wait(_obj, 0, CHECK); } // wait forever 250 void wait_uninterruptibly(TRAPS) { ObjectSynchronizer::waitUninterruptibly(_obj, 0, CHECK); } // wait forever 251 void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); } 252 }; 253 254 // Interface to visit monitors 255 class ObjectMonitorsView { 256 public: 257 // Visit monitors that belong to the given thread 258 virtual void visit(MonitorClosure* closure, JavaThread* thread) = 0; 259 }; 260 261 #endif // SHARE_RUNTIME_SYNCHRONIZER_HPP --- EOF ---