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 74 public: 75 typedef enum { 76 inflate_cause_vm_internal = 0, 77 inflate_cause_monitor_enter = 1, 78 inflate_cause_wait = 2, 79 inflate_cause_notify = 3, 80 inflate_cause_hash_code = 4, 81 inflate_cause_jni_enter = 5, 82 inflate_cause_jni_exit = 6, 83 inflate_cause_nof = 7 // Number of causes 84 } InflateCause; 85 86 typedef enum { 87 NOT_ENABLED = 0, 88 FATAL_EXIT = 1, 89 LOG_WARNING = 2 90 } SyncDiagnosticOption; 91 92 // exit must be implemented non-blocking, since the compiler cannot easily handle 93 // deoptimization at monitor exit. Hence, it does not take a Handle argument. 94 95 // This is the "slow path" version of monitor enter and exit. 96 static inline void enter(Handle obj, BasicLock* lock, JavaThread* current); 97 static inline void exit(oop obj, BasicLock* lock, JavaThread* current); 98 99 // Used to enter a monitor for another thread. This requires that the 100 // locking_thread is suspended, and that entering on a potential 101 // inflated monitor may only contend with deflation. That is the obj being 102 // locked on is either already locked by the locking_thread or cannot 103 // escape the locking_thread. 104 static void enter_for(Handle obj, BasicLock* lock, JavaThread* locking_thread); 105 private: 106 // Shared implementation for enter and enter_for. Performs all but 107 // inflated monitor enter. 108 static bool enter_fast_impl(Handle obj, BasicLock* lock, JavaThread* locking_thread); 109 110 static bool quick_enter_legacy(oop obj, JavaThread* current, BasicLock* Lock); 111 static void enter_legacy(Handle obj, BasicLock* Lock, JavaThread* current); 112 static void exit_legacy(oop obj, BasicLock* lock, JavaThread* current); 113 public: 114 // Used only to handle jni locks or other unmatched monitor enter/exit 115 // Internally they will use heavy weight monitor. 116 static void jni_enter(Handle obj, JavaThread* current); 117 static void jni_exit(oop obj, TRAPS); 118 119 // Handle all interpreter, compiler and jni cases 120 static int wait(Handle obj, jlong millis, TRAPS); 121 static void notify(Handle obj, TRAPS); 122 static void notifyall(Handle obj, TRAPS); 123 124 static bool quick_notify(oopDesc* obj, JavaThread* current, bool All); 125 static inline bool quick_enter(oop obj, JavaThread* current, BasicLock* Lock); 126 127 // Inflate light weight monitor to heavy weight monitor 128 static ObjectMonitor* inflate(Thread* current, oop obj, const InflateCause cause); 129 // Used to inflate a monitor as if it was done from the thread JavaThread. 130 static ObjectMonitor* inflate_for(JavaThread* thread, oop obj, const InflateCause cause); 131 132 private: 133 // Shared implementation between the different LockingMode. 134 static ObjectMonitor* inflate_impl(oop obj, const InflateCause cause); 135 136 public: 137 // This version is only for internal use 138 static void inflate_helper(oop obj); 139 static const char* inflate_cause_name(const InflateCause cause); 140 141 inline static ObjectMonitor* read_monitor(markWord mark); 142 inline static ObjectMonitor* read_monitor(Thread* current, oop obj, markWord mark); 143 144 // Returns the identity hash value for an oop 145 // NOTE: It may cause monitor inflation 146 static intptr_t FastHashCode(Thread* current, oop obj); 147 148 // java.lang.Thread support 149 static bool current_thread_holds_lock(JavaThread* current, Handle h_obj); 150 151 static JavaThread* get_lock_owner(ThreadsList * t_list, Handle h_obj); 152 153 // JNI detach support 154 static void release_monitors_owned_by_thread(JavaThread* current); 155 156 // Iterate over all ObjectMonitors. 157 template <typename Function> 158 static void monitors_iterate(Function function); 159 160 // Iterate ObjectMonitors owned by any thread and where the owner `filter` 161 // returns true. 162 template <typename OwnerFilter> 163 static void owned_monitors_iterate_filtered(MonitorClosure* closure, OwnerFilter filter); 164 165 // Iterate ObjectMonitors where the owner == thread; this does NOT include 166 // ObjectMonitors where owner is set to a stack lock address in thread. 167 static void owned_monitors_iterate(MonitorClosure* m, JavaThread* thread); 168 169 // Iterate ObjectMonitors owned by any thread. 170 static void owned_monitors_iterate(MonitorClosure* closure); 171 172 // Initialize the gInflationLocks 173 static void initialize(); 174 175 // We currently use aggressive monitor deflation policy; 176 // basically we try to deflate all monitors that are not busy. 177 static size_t deflate_idle_monitors(); 178 179 // Deflate idle monitors: 180 static size_t deflate_monitor_list(ObjectMonitorDeflationSafepointer* safepointer); 181 static size_t in_use_list_ceiling(); 182 static void dec_in_use_list_ceiling(); 183 static void inc_in_use_list_ceiling(); 184 static void set_in_use_list_ceiling(size_t new_value); 185 static bool is_async_deflation_needed(); 186 static bool is_async_deflation_requested() { return _is_async_deflation_requested; } 187 static bool is_final_audit() { return _is_final_audit; } 188 static void set_is_final_audit() { _is_final_audit = true; } 189 static jlong last_async_deflation_time_ns() { return _last_async_deflation_time_ns; } 190 static void request_deflate_idle_monitors(); 191 static bool request_deflate_idle_monitors_from_wb(); // for whitebox test support 192 static void set_is_async_deflation_requested(bool new_value) { _is_async_deflation_requested = new_value; } 193 static jlong time_since_last_async_deflation_ms(); 194 195 // debugging 196 static void audit_and_print_stats(outputStream* out, bool on_exit); 197 static void chk_in_use_list(outputStream* out, int* error_cnt_p); 198 static void chk_in_use_entry(ObjectMonitor* n, outputStream* out, 199 int* error_cnt_p); 200 static void do_final_audit_and_print_stats(); 201 static void log_in_use_monitor_details(outputStream* out, bool log_all); 202 203 private: 204 friend class SynchronizerTest; 205 friend class LightweightSynchronizer; 206 207 static MonitorList _in_use_list; 208 static volatile bool _is_async_deflation_requested; 209 static volatile bool _is_final_audit; 210 static jlong _last_async_deflation_time_ns; 211 212 // Support for SynchronizerTest access to GVars fields: 213 static u_char* get_gvars_addr(); 214 static u_char* get_gvars_hc_sequence_addr(); 215 static size_t get_gvars_size(); 216 static u_char* get_gvars_stw_random_addr(); 217 218 static void handle_sync_on_value_based_class(Handle obj, JavaThread* locking_thread); 219 }; 220 221 // ObjectLocker enforces balanced locking and can never throw an 222 // IllegalMonitorStateException. However, a pending exception may 223 // have to pass through, and we must also be able to deal with 224 // asynchronous exceptions. The caller is responsible for checking 225 // the thread's pending exception if needed. 226 class ObjectLocker : public StackObj { 227 private: 228 JavaThread* _thread; 229 Handle _obj; 230 BasicLock _lock; 231 public: 232 ObjectLocker(Handle obj, JavaThread* current); 233 ~ObjectLocker(); 234 235 // Monitor behavior 236 void wait(TRAPS) { ObjectSynchronizer::wait(_obj, 0, CHECK); } // wait forever 237 void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); } 238 }; 239 240 // Interface to visit monitors 241 class ObjectMonitorsView { 242 public: 243 // Visit monitors that belong to the given thread 244 virtual void visit(MonitorClosure* closure, JavaThread* thread) = 0; 245 }; 246 247 #endif // SHARE_RUNTIME_SYNCHRONIZER_HPP --- EOF ---