151 sizeof(ObjectMonitor *));
152 protected: // protected for JvmtiRawMonitor
153 // Used by async deflation as a marker in the _owner field:
154 #define DEFLATER_MARKER reinterpret_cast<void*>(-1)
155 void * volatile _owner; // pointer to owning thread OR BasicLock
156 volatile jlong _previous_owner_tid; // thread id of the previous owner of the monitor
157 volatile intptr_t _recursions; // recursion count, 0 for first entry
158 ObjectWaiter * volatile _EntryList; // Threads blocked on entry or reentry.
159 // The list is actually composed of WaitNodes,
160 // acting as proxies for Threads.
161 private:
162 ObjectWaiter * volatile _cxq; // LL of recently-arrived threads blocked on entry.
163 Thread * volatile _succ; // Heir presumptive thread - used for futile wakeup throttling
164 Thread * volatile _Responsible;
165
166 volatile int _Spinner; // for exit->spinner handoff optimization
167 volatile int _SpinDuration;
168
169 volatile jint _contentions; // Number of active contentions in enter(). It is used by is_busy()
170 // along with other fields to determine if an ObjectMonitor can be
171 // deflated. See ObjectSynchronizer::deflate_monitor().
172 protected:
173 ObjectWaiter * volatile _WaitSet; // LL of threads wait()ing on the monitor
174 volatile jint _waiters; // number of waiting threads
175 private:
176 volatile int _WaitSetLock; // protects Wait Queue - simple spinlock
177 volatile jint _ref_count; // ref count for ObjectMonitor*
178 typedef enum {
179 Free = 0, // Free must be 0 for monitor to be free after memset(..,0,..).
180 New,
181 Old
182 } AllocationState;
183 AllocationState _allocation_state;
184
185 public:
186 static void Initialize();
187
188 // Only perform a PerfData operation if the PerfData object has been
189 // allocated and if the PerfDataManager has not freed the PerfData
190 // objects which can happen at normal VM shutdown.
191 //
192 #define OM_PERFDATA_OP(f, op_str) \
193 do { \
194 if (ObjectMonitor::_sync_ ## f != NULL && \
195 PerfDataManager::has_PerfData()) { \
196 ObjectMonitor::_sync_ ## f->op_str; \
197 } \
232 // reference. The latter avoids an AGI (Address Generation Interlock)
233 // stall so the helper macro adjusts the offset value that is returned
234 // to the ObjectMonitor reference manipulation code:
235 //
236 #define OM_OFFSET_NO_MONITOR_VALUE_TAG(f) \
237 ((ObjectMonitor::f ## _offset_in_bytes()) - markOopDesc::monitor_value)
238
239 markOop header() const;
240 volatile markOop* header_addr();
241 void set_header(markOop hdr);
242
243 intptr_t is_busy() const {
244 // TODO-FIXME: assert _owner == null implies _recursions = 0
245 // We do not include _ref_count in the is_busy() check because
246 // _ref_count is for indicating that the ObjectMonitor* is in
247 // use which is orthogonal to whether the ObjectMonitor itself
248 // is in use for a locking operation.
249 return _contentions|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList);
250 }
251
252 // Version of is_busy() that accounts for special values in
253 // _contentions and _owner when AsyncDeflateIdleMonitors is enabled.
254 intptr_t is_busy_async() const {
255 intptr_t ret_code = _waiters | intptr_t(_cxq) | intptr_t(_EntryList);
256 if (!AsyncDeflateIdleMonitors) {
257 ret_code |= _contentions | intptr_t(_owner);
258 } else {
259 if (_contentions > 0) {
260 ret_code |= _contentions;
261 }
262 if (_owner != DEFLATER_MARKER) {
263 ret_code |= intptr_t(_owner);
264 }
265 }
266 return ret_code;
267 }
268
269 intptr_t is_entered(Thread* current) const;
270
271 void* owner() const; // Returns NULL if DEFLATER_MARKER is observed.
272 void set_owner(void* owner);
273
274 jint waiters() const;
275
276 jint contentions() const;
277 intptr_t recursions() const { return _recursions; }
278
279 // JVM/TI GetObjectMonitorUsage() needs this:
280 ObjectWaiter* first_waiter() { return _WaitSet; }
281 ObjectWaiter* next_waiter(ObjectWaiter* o) { return o->_next; }
309 public:
310
311 void* object() const;
312 void* object_addr();
313 void set_object(void* obj);
314 void set_allocation_state(AllocationState s);
315 AllocationState allocation_state() const;
316 bool is_free() const;
317 bool is_active() const;
318 bool is_old() const;
319 bool is_new() const;
320 void dec_ref_count();
321 void inc_ref_count();
322 jint ref_count() const;
323
324 bool check(TRAPS); // true if the thread owns the monitor.
325 void check_slow(TRAPS);
326 void clear();
327 void clear_using_JT();
328
329 bool enter(TRAPS); // Returns false if monitor is being async deflated and caller should retry locking the object.
330 void exit(bool not_suspended, TRAPS);
331 void wait(jlong millis, bool interruptable, TRAPS);
332 void notify(TRAPS);
333 void notifyAll(TRAPS);
334
335 // Use the following at your own risk
336 intptr_t complete_exit(TRAPS);
337 bool reenter(intptr_t recursions, TRAPS); // Returns false if monitor is being async deflated and caller should retry locking the object.
338
339 private:
340 void AddWaiter(ObjectWaiter * waiter);
341 void INotify(Thread * Self);
342 ObjectWaiter * DequeueWaiter();
343 void DequeueSpecificWaiter(ObjectWaiter * waiter);
344 void EnterI(TRAPS);
345 void ReenterI(Thread * Self, ObjectWaiter * SelfNode);
346 void UnlinkAfterAcquire(Thread * Self, ObjectWaiter * SelfNode);
347 int TryLock(Thread * Self);
348 int NotRunnable(Thread * Self, Thread * Owner);
349 int TrySpin(Thread * Self);
350 void ExitEpilog(Thread * Self, ObjectWaiter * Wakee);
351 bool ExitSuspendEquivalent(JavaThread * Self);
352 void install_displaced_markword_in_object(const oop obj);
353 };
354
355 // A helper object for managing an ObjectMonitor*'s ref_count. There
356 // are special safety considerations when async deflation is used.
357 class ObjectMonitorHandle : public StackObj {
|
151 sizeof(ObjectMonitor *));
152 protected: // protected for JvmtiRawMonitor
153 // Used by async deflation as a marker in the _owner field:
154 #define DEFLATER_MARKER reinterpret_cast<void*>(-1)
155 void * volatile _owner; // pointer to owning thread OR BasicLock
156 volatile jlong _previous_owner_tid; // thread id of the previous owner of the monitor
157 volatile intptr_t _recursions; // recursion count, 0 for first entry
158 ObjectWaiter * volatile _EntryList; // Threads blocked on entry or reentry.
159 // The list is actually composed of WaitNodes,
160 // acting as proxies for Threads.
161 private:
162 ObjectWaiter * volatile _cxq; // LL of recently-arrived threads blocked on entry.
163 Thread * volatile _succ; // Heir presumptive thread - used for futile wakeup throttling
164 Thread * volatile _Responsible;
165
166 volatile int _Spinner; // for exit->spinner handoff optimization
167 volatile int _SpinDuration;
168
169 volatile jint _contentions; // Number of active contentions in enter(). It is used by is_busy()
170 // along with other fields to determine if an ObjectMonitor can be
171 // deflated. See ObjectSynchronizer::deflate_monitor() and
172 // ObjectSynchronizer::deflate_monitor_using_JT().
173 protected:
174 ObjectWaiter * volatile _WaitSet; // LL of threads wait()ing on the monitor
175 volatile jint _waiters; // number of waiting threads
176 private:
177 volatile int _WaitSetLock; // protects Wait Queue - simple spinlock
178 volatile jint _ref_count; // ref count for ObjectMonitor* and used by the async deflation
179 // protocol. See ObjectSynchronizer::deflate_monitor_using_JT().
180 typedef enum {
181 Free = 0, // Free must be 0 for monitor to be free after memset(..,0,..).
182 New,
183 Old
184 } AllocationState;
185 AllocationState _allocation_state;
186
187 public:
188 static void Initialize();
189
190 // Only perform a PerfData operation if the PerfData object has been
191 // allocated and if the PerfDataManager has not freed the PerfData
192 // objects which can happen at normal VM shutdown.
193 //
194 #define OM_PERFDATA_OP(f, op_str) \
195 do { \
196 if (ObjectMonitor::_sync_ ## f != NULL && \
197 PerfDataManager::has_PerfData()) { \
198 ObjectMonitor::_sync_ ## f->op_str; \
199 } \
234 // reference. The latter avoids an AGI (Address Generation Interlock)
235 // stall so the helper macro adjusts the offset value that is returned
236 // to the ObjectMonitor reference manipulation code:
237 //
238 #define OM_OFFSET_NO_MONITOR_VALUE_TAG(f) \
239 ((ObjectMonitor::f ## _offset_in_bytes()) - markOopDesc::monitor_value)
240
241 markOop header() const;
242 volatile markOop* header_addr();
243 void set_header(markOop hdr);
244
245 intptr_t is_busy() const {
246 // TODO-FIXME: assert _owner == null implies _recursions = 0
247 // We do not include _ref_count in the is_busy() check because
248 // _ref_count is for indicating that the ObjectMonitor* is in
249 // use which is orthogonal to whether the ObjectMonitor itself
250 // is in use for a locking operation.
251 return _contentions|_waiters|intptr_t(_owner)|intptr_t(_cxq)|intptr_t(_EntryList);
252 }
253
254 // Version of is_busy() that accounts for the special value in
255 // _owner when AsyncDeflateIdleMonitors is enabled.
256 intptr_t is_busy_async() const {
257 intptr_t ret_code = _contentions | _waiters | intptr_t(_cxq) | intptr_t(_EntryList);
258 if (!AsyncDeflateIdleMonitors) {
259 ret_code |= intptr_t(_owner);
260 } else {
261 if (_owner != DEFLATER_MARKER) {
262 ret_code |= intptr_t(_owner);
263 }
264 }
265 return ret_code;
266 }
267
268 intptr_t is_entered(Thread* current) const;
269
270 void* owner() const; // Returns NULL if DEFLATER_MARKER is observed.
271 void set_owner(void* owner);
272
273 jint waiters() const;
274
275 jint contentions() const;
276 intptr_t recursions() const { return _recursions; }
277
278 // JVM/TI GetObjectMonitorUsage() needs this:
279 ObjectWaiter* first_waiter() { return _WaitSet; }
280 ObjectWaiter* next_waiter(ObjectWaiter* o) { return o->_next; }
308 public:
309
310 void* object() const;
311 void* object_addr();
312 void set_object(void* obj);
313 void set_allocation_state(AllocationState s);
314 AllocationState allocation_state() const;
315 bool is_free() const;
316 bool is_active() const;
317 bool is_old() const;
318 bool is_new() const;
319 void dec_ref_count();
320 void inc_ref_count();
321 jint ref_count() const;
322
323 bool check(TRAPS); // true if the thread owns the monitor.
324 void check_slow(TRAPS);
325 void clear();
326 void clear_using_JT();
327
328 void enter(TRAPS);
329 void exit(bool not_suspended, TRAPS);
330 void wait(jlong millis, bool interruptable, TRAPS);
331 void notify(TRAPS);
332 void notifyAll(TRAPS);
333
334 // Use the following at your own risk
335 intptr_t complete_exit(TRAPS);
336 void reenter(intptr_t recursions, TRAPS);
337
338 private:
339 void AddWaiter(ObjectWaiter * waiter);
340 void INotify(Thread * Self);
341 ObjectWaiter * DequeueWaiter();
342 void DequeueSpecificWaiter(ObjectWaiter * waiter);
343 void EnterI(TRAPS);
344 void ReenterI(Thread * Self, ObjectWaiter * SelfNode);
345 void UnlinkAfterAcquire(Thread * Self, ObjectWaiter * SelfNode);
346 int TryLock(Thread * Self);
347 int NotRunnable(Thread * Self, Thread * Owner);
348 int TrySpin(Thread * Self);
349 void ExitEpilog(Thread * Self, ObjectWaiter * Wakee);
350 bool ExitSuspendEquivalent(JavaThread * Self);
351 void install_displaced_markword_in_object(const oop obj);
352 };
353
354 // A helper object for managing an ObjectMonitor*'s ref_count. There
355 // are special safety considerations when async deflation is used.
356 class ObjectMonitorHandle : public StackObj {
|