1 /* 2 * Copyright (c) 1998, 2025, 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/hashTable.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 MonitorList() : _head(nullptr), _count(0), _max(0) {}; 51 void add(ObjectMonitor* monitor); 52 size_t unlink_deflated(size_t deflated_count, 53 GrowableArray<ObjectMonitor*>* unlinked_list, 54 ObjectMonitorDeflationSafepointer* safepointer); 55 size_t count() const; 56 size_t max() const; 57 58 class Iterator; 59 Iterator iterator() const; 60 }; 61 62 class MonitorList::Iterator { 63 ObjectMonitor* _current; 64 65 public: 66 Iterator(ObjectMonitor* head) : _current(head) {} 67 bool has_next() const { return _current != nullptr; } 68 ObjectMonitor* next(); 69 }; 70 71 class ObjectSynchronizer : AllStatic { 72 friend class VMStructs; 73 friend class ObjectMonitorDeflationLogging; 74 friend class WhiteBox; 75 76 public: 77 typedef enum { 78 inflate_cause_vm_internal = 0, 79 inflate_cause_monitor_enter = 1, 80 inflate_cause_wait = 2, 81 inflate_cause_notify = 3, 82 inflate_cause_jni_enter = 4, 83 inflate_cause_jni_exit = 5, 84 inflate_cause_nof = 6 // 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 107 // Used only to handle jni locks or other unmatched monitor enter/exit 108 // Internally they will use heavy weight monitor. 109 static void jni_enter(Handle obj, JavaThread* current); 110 static void jni_exit(oop obj, TRAPS); 111 112 // Handle all interpreter, compiler and jni cases 113 static int wait(Handle obj, jlong millis, TRAPS); 114 static void notify(Handle obj, TRAPS); 115 static void notifyall(Handle obj, TRAPS); 116 117 static bool quick_notify(oopDesc* obj, JavaThread* current, bool All); 118 static inline bool quick_enter(oop obj, BasicLock* Lock, JavaThread* current); 119 120 // Special internal-use-only method for use by JVM infrastructure 121 // that needs to wait() on a java-level object but that can't risk 122 // throwing unexpected InterruptedExecutionExceptions. 123 static void waitUninterruptibly(Handle obj, jlong Millis, TRAPS); 124 125 public: 126 static const char* inflate_cause_name(const InflateCause cause); 127 128 inline static ObjectMonitor* read_monitor(markWord mark); 129 inline static ObjectMonitor* read_monitor(Thread* current, oop obj); 130 inline static ObjectMonitor* read_monitor(Thread* current, oop obj, markWord mark); 131 132 // Returns the identity hash value for an oop 133 // NOTE: It may cause monitor inflation 134 static intptr_t FastHashCode(Thread* current, oop obj); 135 136 // java.lang.Thread support 137 static bool current_thread_holds_lock(JavaThread* current, Handle h_obj); 138 139 static JavaThread* get_lock_owner(ThreadsList * t_list, Handle h_obj); 140 141 // JNI detach support 142 static void release_monitors_owned_by_thread(JavaThread* current); 143 144 // Iterate over all ObjectMonitors. 145 template <typename Function> 146 static void monitors_iterate(Function function); 147 148 // Iterate ObjectMonitors owned by any thread and where the owner `filter` 149 // returns true. 150 template <typename OwnerFilter> 151 static void owned_monitors_iterate_filtered(MonitorClosure* closure, OwnerFilter filter); 152 153 // Iterate ObjectMonitors where the owner is thread; this does NOT include 154 // ObjectMonitors where the owner is anonymous. 155 static void owned_monitors_iterate(MonitorClosure* m, JavaThread* thread); 156 157 // Iterate ObjectMonitors where the owner is vthread. 158 static void owned_monitors_iterate(MonitorClosure* m, oop vthread); 159 160 // Iterate ObjectMonitors owned by any thread. 161 static void owned_monitors_iterate(MonitorClosure* closure); 162 163 // Initialize the gInflationLocks 164 static void initialize(); 165 166 // We currently use aggressive monitor deflation policy; 167 // basically we try to deflate all monitors that are not busy. 168 static size_t deflate_idle_monitors(); 169 170 // Deflate idle monitors: 171 static size_t deflate_monitor_list(ObjectMonitorDeflationSafepointer* safepointer); 172 static size_t in_use_list_count(); 173 static size_t in_use_list_max(); 174 static size_t in_use_list_ceiling(); 175 static void dec_in_use_list_ceiling(); 176 static void inc_in_use_list_ceiling(); 177 static void set_in_use_list_ceiling(size_t new_value); 178 static bool is_async_deflation_needed(); 179 static bool is_async_deflation_requested() { return _is_async_deflation_requested; } 180 static bool is_final_audit() { return _is_final_audit; } 181 static void set_is_final_audit() { _is_final_audit = true; } 182 static jlong last_async_deflation_time_ns() { return _last_async_deflation_time_ns; } 183 static void request_deflate_idle_monitors(); 184 static bool request_deflate_idle_monitors_from_wb(); // for whitebox test support 185 static void set_is_async_deflation_requested(bool new_value) { _is_async_deflation_requested = new_value; } 186 static jlong time_since_last_async_deflation_ms(); 187 188 // debugging 189 static void audit_and_print_stats(outputStream* out, bool on_exit); 190 static void chk_in_use_list(outputStream* out, int* error_cnt_p); 191 static void chk_in_use_entry(ObjectMonitor* n, outputStream* out, 192 int* error_cnt_p); 193 static void do_final_audit_and_print_stats(); 194 static void log_in_use_monitor_details(outputStream* out, bool log_all); 195 196 private: 197 friend class SynchronizerTest; 198 friend class LightweightSynchronizer; 199 200 static MonitorList _in_use_list; 201 static volatile bool _is_async_deflation_requested; 202 static volatile bool _is_final_audit; 203 static jlong _last_async_deflation_time_ns; 204 205 // Support for SynchronizerTest access to GVars fields: 206 static u_char* get_gvars_addr(); 207 static u_char* get_gvars_hc_sequence_addr(); 208 static size_t get_gvars_size(); 209 static u_char* get_gvars_stw_random_addr(); 210 211 static void handle_sync_on_value_based_class(Handle obj, JavaThread* locking_thread); 212 }; 213 214 // ObjectLocker enforces balanced locking and can never throw an 215 // IllegalMonitorStateException. However, a pending exception may 216 // have to pass through, and we must also be able to deal with 217 // asynchronous exceptions. The caller is responsible for checking 218 // the thread's pending exception if needed. 219 // When using ObjectLocker the top native frames in the stack will 220 // not be seen in case we attempt preemption, since we start walking 221 // from the last Java anchor, so we disable it with NoPreemptMark. 222 class ObjectLocker : public StackObj { 223 private: 224 JavaThread* _thread; 225 Handle _obj; 226 BasicLock _lock; 227 NoPreemptMark _npm; 228 bool _skip_exit; 229 public: 230 ObjectLocker(Handle obj, TRAPS); 231 ~ObjectLocker(); 232 233 // Monitor behavior 234 void wait_uninterruptibly(TRAPS); 235 void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); } 236 }; 237 238 // Interface to visit monitors 239 class ObjectMonitorsView { 240 public: 241 // Visit monitors that belong to the given thread 242 virtual void visit(MonitorClosure* closure, JavaThread* thread) = 0; 243 }; 244 245 #endif // SHARE_RUNTIME_SYNCHRONIZER_HPP