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