author | coleenp |
Thu, 25 Apr 2019 10:56:31 -0400 | |
changeset 54623 | 1126f0607c70 |
parent 54495 | 941db9c0b5b5 |
child 54663 | f03d5a093093 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
2 |
* Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
26 |
#include "logging/log.hpp" |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
48488
diff
changeset
|
27 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 28 |
#include "runtime/mutex.hpp" |
29 |
#include "runtime/osThread.hpp" |
|
47881
0ce0ac68ace7
8189941: Implementation JEP 312: Thread-local handshake
rehn
parents:
47634
diff
changeset
|
30 |
#include "runtime/safepointMechanism.inline.hpp" |
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
11636
diff
changeset
|
31 |
#include "runtime/thread.inline.hpp" |
7397 | 32 |
#include "utilities/events.hpp" |
40010 | 33 |
#include "utilities/macros.hpp" |
1 | 34 |
|
35 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
36 |
void Monitor::lock(Thread * self) { |
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
37 |
// Ensure that the Monitor requires/allows safepoint checks. |
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
38 |
assert(_safepoint_check_required != Monitor::_safepoint_check_never, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
39 |
"This lock should never have a safepoint check: %s", name()); |
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
40 |
|
1 | 41 |
#ifdef CHECK_UNHANDLED_OOPS |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
42 |
// Clear unhandled oops in JavaThreads so we get a crash right away. |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
43 |
if (self->is_Java_thread()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
44 |
self->clear_unhandled_oops(); |
1 | 45 |
} |
46 |
#endif // CHECK_UNHANDLED_OOPS |
|
47 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
48 |
DEBUG_ONLY(check_prelock_state(self, StrictSafepointChecks)); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
49 |
assert(_owner != self, "invariant"); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
50 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
51 |
Monitor* in_flight_monitor = NULL; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
52 |
DEBUG_ONLY(int retry_cnt = 0;) |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
53 |
while (!_lock.try_lock()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
54 |
// The lock is contended |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
55 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
56 |
#ifdef ASSERT |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
57 |
check_block_state(self); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
58 |
if (retry_cnt++ > 3) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
59 |
log_trace(vmmonitor)("JavaThread " INTPTR_FORMAT " on %d attempt trying to acquire vmmonitor %s", p2i(self), retry_cnt, _name); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
60 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
61 |
#endif // ASSERT |
1 | 62 |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
63 |
if (self->is_Java_thread()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
64 |
assert(rank() > Mutex::special, "Potential deadlock with special or lesser rank mutex"); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
65 |
{ ThreadBlockInVMWithDeadlockCheck tbivmdc((JavaThread *) self, &in_flight_monitor); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
66 |
in_flight_monitor = this; // save for ~ThreadBlockInVMWithDeadlockCheck |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
67 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
68 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
69 |
if (in_flight_monitor != NULL) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
70 |
// Not unlocked by ~ThreadBlockInVMWithDeadlockCheck |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
71 |
break; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
72 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
73 |
} else { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
74 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
75 |
break; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
76 |
} |
1 | 77 |
} |
78 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
79 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
80 |
set_owner(self); |
1 | 81 |
} |
82 |
||
83 |
void Monitor::lock() { |
|
84 |
this->lock(Thread::current()); |
|
85 |
} |
|
86 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
87 |
// Lock without safepoint check - a degenerate variant of lock() for use by |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
88 |
// JavaThreads when it is known to be safe to not check for a safepoint when |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
89 |
// acquiring this lock. If the thread blocks acquiring the lock it is not |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
90 |
// safepoint-safe and so will prevent a safepoint from being reached. If used |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
91 |
// in the wrong way this can lead to a deadlock with the safepoint code. |
1 | 92 |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
93 |
void Monitor::lock_without_safepoint_check(Thread * self) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
94 |
// Ensure that the Monitor does not require safepoint checks. |
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
95 |
assert(_safepoint_check_required != Monitor::_safepoint_check_always, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
96 |
"This lock should always have a safepoint check: %s", name()); |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
97 |
assert(_owner != self, "invariant"); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
98 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
99 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
100 |
set_owner(self); |
1 | 101 |
} |
102 |
||
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
103 |
void Monitor::lock_without_safepoint_check() { |
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
104 |
lock_without_safepoint_check(Thread::current()); |
1 | 105 |
} |
106 |
||
107 |
||
22551 | 108 |
// Returns true if thread succeeds in grabbing the lock, otherwise false. |
1 | 109 |
|
110 |
bool Monitor::try_lock() { |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
111 |
Thread * const self = Thread::current(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
112 |
DEBUG_ONLY(check_prelock_state(self, false);) |
1 | 113 |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
114 |
if (_lock.try_lock()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
115 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
116 |
set_owner(self); |
1 | 117 |
return true; |
118 |
} |
|
119 |
return false; |
|
120 |
} |
|
121 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
122 |
void Monitor::release_for_safepoint() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
123 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
124 |
_lock.unlock(); |
1 | 125 |
} |
126 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
127 |
void Monitor::unlock() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
128 |
assert_owner(Thread::current()); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
129 |
set_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
130 |
_lock.unlock(); |
1 | 131 |
} |
132 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
133 |
void Monitor::notify() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
134 |
assert_owner(Thread::current()); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
135 |
_lock.notify(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
136 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
137 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
138 |
void Monitor::notify_all() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
139 |
assert_owner(Thread::current()); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
140 |
_lock.notify_all(); |
1 | 141 |
} |
142 |
||
54495
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
143 |
#ifdef ASSERT |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
144 |
void Monitor::assert_wait_lock_state(Thread* self) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
145 |
Monitor* least = get_least_ranked_lock_besides_this(self->owned_locks()); |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
146 |
assert(least != this, "Specification of get_least_... call above"); |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
147 |
if (least != NULL && least->rank() <= special) { |
52913
bf2f2560dd53
8214315: G1: fatal error: acquiring lock SATB_Q_FL_lock/1 out of order with lock tty_lock/0
kbarrett
parents:
52581
diff
changeset
|
148 |
::tty->print("Attempting to wait on monitor %s/%d while holding" |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
149 |
" lock %s/%d -- possible deadlock", |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
150 |
name(), rank(), least->name(), least->rank()); |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
151 |
assert(false, "Shouldn't block(wait) while holding a lock of rank special"); |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
152 |
} |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
153 |
} |
54495
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
154 |
#endif // ASSERT |
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
155 |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
156 |
bool Monitor::wait_without_safepoint_check(long timeout) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
157 |
// Make sure safepoint checking is used properly. |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
158 |
assert(_safepoint_check_required != Monitor::_safepoint_check_always, |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
159 |
"This lock should always have a safepoint check: %s", name()); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
160 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
161 |
// timeout is in milliseconds - with zero meaning never timeout |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
162 |
assert(timeout >= 0, "negative timeout"); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
163 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
164 |
Thread * const self = Thread::current(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
165 |
assert_owner(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
166 |
assert_wait_lock_state(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
167 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
168 |
// conceptually set the owner to NULL in anticipation of |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
169 |
// abdicating the lock in wait |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
170 |
set_owner(NULL); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
171 |
int wait_status = _lock.wait(timeout); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
172 |
set_owner(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
173 |
return wait_status != 0; // return true IFF timeout |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
174 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
175 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
176 |
bool Monitor::wait(long timeout, bool as_suspend_equivalent) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
177 |
// Make sure safepoint checking is used properly. |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
178 |
assert(_safepoint_check_required != Monitor::_safepoint_check_never, |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
179 |
"This lock should never have a safepoint check: %s", name()); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
180 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
181 |
// timeout is in milliseconds - with zero meaning never timeout |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
182 |
assert(timeout >= 0, "negative timeout"); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
183 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
184 |
Thread* const self = Thread::current(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
185 |
assert_owner(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
186 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
187 |
// Safepoint checking logically implies java_thread |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
188 |
guarantee(self->is_Java_thread(), "invariant"); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
189 |
assert_wait_lock_state(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
190 |
|
54495
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
191 |
#ifdef CHECK_UNHANDLED_OOPS |
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
192 |
// Clear unhandled oops in JavaThreads so we get a crash right away. |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
193 |
self->clear_unhandled_oops(); |
54495
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
194 |
#endif // CHECK_UNHANDLED_OOPS |
1 | 195 |
|
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
196 |
int wait_status; |
1 | 197 |
// conceptually set the owner to NULL in anticipation of |
198 |
// abdicating the lock in wait |
|
199 |
set_owner(NULL); |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
200 |
JavaThread *jt = (JavaThread *)self; |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
201 |
Monitor* in_flight_monitor = NULL; |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
202 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
203 |
{ |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
204 |
ThreadBlockInVMWithDeadlockCheck tbivmdc(jt, &in_flight_monitor); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
205 |
OSThreadWaitState osts(self->osthread(), false /* not Object.wait() */); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
206 |
if (as_suspend_equivalent) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
207 |
jt->set_suspend_equivalent(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
208 |
// cleared by handle_special_suspend_equivalent_condition() or |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
209 |
// java_suspend_self() |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
210 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
211 |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
212 |
wait_status = _lock.wait(timeout); |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
213 |
in_flight_monitor = this; // save for ~ThreadBlockInVMWithDeadlockCheck |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
214 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
215 |
// were we externally suspended while we were waiting? |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
216 |
if (as_suspend_equivalent && jt->handle_special_suspend_equivalent_condition()) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
217 |
// Our event wait has finished and we own the lock, but |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
218 |
// while we were waiting another thread suspended us. We don't |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
219 |
// want to hold the lock while suspended because that |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
220 |
// would surprise the thread that suspended us. |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
221 |
_lock.unlock(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
222 |
jt->java_suspend_self(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
223 |
_lock.lock(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
224 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
225 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
226 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
227 |
if (in_flight_monitor != NULL) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
228 |
// Not unlocked by ~ThreadBlockInVMWithDeadlockCheck |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
229 |
assert_owner(NULL); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
230 |
// Conceptually reestablish ownership of the lock. |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
231 |
set_owner(self); |
1 | 232 |
} else { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
233 |
lock(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
234 |
} |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
235 |
|
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
236 |
return wait_status != 0; // return true IFF timeout |
1 | 237 |
} |
238 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
239 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
240 |
// Temporary JVM_RawMonitor* support. |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
241 |
// Yet another degenerate version of Monitor::lock() or lock_without_safepoint_check() |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
242 |
// jvm_raw_lock() and _unlock() can be called by non-Java threads via JVM_RawMonitorEnter. |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
243 |
// There's no expectation that JVM_RawMonitors will interoperate properly with the native |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
244 |
// Mutex-Monitor constructs. We happen to implement JVM_RawMonitors in terms of |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
245 |
// native Mutex-Monitors simply as a matter of convenience. |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
246 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
247 |
void Monitor::jvm_raw_lock() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
248 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
249 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
250 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
251 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
252 |
void Monitor::jvm_raw_unlock() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
253 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
254 |
_lock.unlock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
255 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
256 |
|
1 | 257 |
Monitor::~Monitor() { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
258 |
assert_owner(NULL); |
1 | 259 |
} |
260 |
||
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
261 |
void Monitor::ClearMonitor(Monitor * m, const char *name) { |
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
262 |
m->_owner = NULL; |
228
69939fa91efd
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
1
diff
changeset
|
263 |
if (name == NULL) { |
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
264 |
strcpy(m->_name, "UNKNOWN"); |
228
69939fa91efd
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
1
diff
changeset
|
265 |
} else { |
69939fa91efd
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
1
diff
changeset
|
266 |
strncpy(m->_name, name, MONITOR_NAME_LEN - 1); |
69939fa91efd
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
1
diff
changeset
|
267 |
m->_name[MONITOR_NAME_LEN - 1] = '\0'; |
69939fa91efd
6610420: Debug VM crashes during monitor lock rank checking
xlu
parents:
1
diff
changeset
|
268 |
} |
1 | 269 |
} |
270 |
||
52581
d402a406bbc3
8213723: More Monitor/mutex initialization management
dholmes
parents:
52555
diff
changeset
|
271 |
Monitor::Monitor() { |
d402a406bbc3
8213723: More Monitor/mutex initialization management
dholmes
parents:
52555
diff
changeset
|
272 |
assert(os::mutex_init_done(), "Too early!"); |
d402a406bbc3
8213723: More Monitor/mutex initialization management
dholmes
parents:
52555
diff
changeset
|
273 |
ClearMonitor(this); |
d402a406bbc3
8213723: More Monitor/mutex initialization management
dholmes
parents:
52555
diff
changeset
|
274 |
} |
1 | 275 |
|
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
276 |
Monitor::Monitor(int Rank, const char * name, bool allow_vm_block, |
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
277 |
SafepointCheckRequired safepoint_check_required) { |
52581
d402a406bbc3
8213723: More Monitor/mutex initialization management
dholmes
parents:
52555
diff
changeset
|
278 |
assert(os::mutex_init_done(), "Too early!"); |
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
279 |
ClearMonitor(this, name); |
1 | 280 |
#ifdef ASSERT |
281 |
_allow_vm_block = allow_vm_block; |
|
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
282 |
_rank = Rank; |
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
283 |
NOT_PRODUCT(_safepoint_check_required = safepoint_check_required;) |
1 | 284 |
#endif |
285 |
} |
|
286 |
||
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
287 |
Mutex::Mutex(int Rank, const char * name, bool allow_vm_block, |
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
288 |
SafepointCheckRequired safepoint_check_required) { |
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
289 |
ClearMonitor((Monitor *) this, name); |
1 | 290 |
#ifdef ASSERT |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
291 |
_allow_vm_block = allow_vm_block; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
292 |
_rank = Rank; |
28163
322d55d167be
8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents:
26684
diff
changeset
|
293 |
NOT_PRODUCT(_safepoint_check_required = safepoint_check_required;) |
1 | 294 |
#endif |
295 |
} |
|
296 |
||
297 |
bool Monitor::owned_by_self() const { |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
298 |
return _owner == Thread::current(); |
1 | 299 |
} |
300 |
||
301 |
void Monitor::print_on_error(outputStream* st) const { |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
302 |
st->print("[" PTR_FORMAT, p2i(this)); |
1 | 303 |
st->print("] %s", _name); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
304 |
st->print(" - owner thread: " PTR_FORMAT, p2i(_owner)); |
1 | 305 |
} |
306 |
||
307 |
// ---------------------------------------------------------------------------------- |
|
308 |
// Non-product code |
|
309 |
||
310 |
#ifndef PRODUCT |
|
311 |
void Monitor::print_on(outputStream* st) const { |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
312 |
st->print_cr("Mutex: [" PTR_FORMAT "] %s - owner: " PTR_FORMAT, |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
313 |
p2i(this), _name, p2i(_owner)); |
1 | 314 |
} |
315 |
#endif |
|
316 |
||
317 |
#ifndef PRODUCT |
|
318 |
#ifdef ASSERT |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
319 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
320 |
void Monitor::assert_owner(Thread * expected) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
321 |
const char* msg = "invalid owner"; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
322 |
if (expected == NULL) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
323 |
msg = "should be un-owned"; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
324 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
325 |
else if (expected == Thread::current()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
326 |
msg = "should be owned by current thread"; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
327 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
328 |
assert(_owner == expected, |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
329 |
"%s: owner=" INTPTR_FORMAT ", should be=" INTPTR_FORMAT, |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
330 |
msg, p2i(_owner), p2i(expected)); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
331 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
332 |
|
1 | 333 |
Monitor * Monitor::get_least_ranked_lock(Monitor * locks) { |
334 |
Monitor *res, *tmp; |
|
335 |
for (res = tmp = locks; tmp != NULL; tmp = tmp->next()) { |
|
336 |
if (tmp->rank() < res->rank()) { |
|
337 |
res = tmp; |
|
338 |
} |
|
339 |
} |
|
340 |
if (!SafepointSynchronize::is_at_safepoint()) { |
|
341 |
// In this case, we expect the held locks to be |
|
342 |
// in increasing rank order (modulo any native ranks) |
|
343 |
for (tmp = locks; tmp != NULL; tmp = tmp->next()) { |
|
344 |
if (tmp->next() != NULL) { |
|
345 |
assert(tmp->rank() == Mutex::native || |
|
346 |
tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?"); |
|
347 |
} |
|
348 |
} |
|
349 |
} |
|
350 |
return res; |
|
351 |
} |
|
352 |
||
353 |
Monitor* Monitor::get_least_ranked_lock_besides_this(Monitor* locks) { |
|
354 |
Monitor *res, *tmp; |
|
355 |
for (res = NULL, tmp = locks; tmp != NULL; tmp = tmp->next()) { |
|
356 |
if (tmp != this && (res == NULL || tmp->rank() < res->rank())) { |
|
357 |
res = tmp; |
|
358 |
} |
|
359 |
} |
|
360 |
if (!SafepointSynchronize::is_at_safepoint()) { |
|
361 |
// In this case, we expect the held locks to be |
|
362 |
// in increasing rank order (modulo any native ranks) |
|
363 |
for (tmp = locks; tmp != NULL; tmp = tmp->next()) { |
|
364 |
if (tmp->next() != NULL) { |
|
365 |
assert(tmp->rank() == Mutex::native || |
|
366 |
tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?"); |
|
367 |
} |
|
368 |
} |
|
369 |
} |
|
370 |
return res; |
|
371 |
} |
|
372 |
||
373 |
||
374 |
bool Monitor::contains(Monitor* locks, Monitor * lock) { |
|
375 |
for (; locks != NULL; locks = locks->next()) { |
|
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
376 |
if (locks == lock) { |
1 | 377 |
return true; |
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
378 |
} |
1 | 379 |
} |
380 |
return false; |
|
381 |
} |
|
382 |
#endif |
|
383 |
||
384 |
// Called immediately after lock acquisition or release as a diagnostic |
|
385 |
// to track the lock-set of the thread and test for rank violations that |
|
386 |
// might indicate exposure to deadlock. |
|
387 |
// Rather like an EventListener for _owner (:>). |
|
388 |
||
389 |
void Monitor::set_owner_implementation(Thread *new_owner) { |
|
390 |
// This function is solely responsible for maintaining |
|
391 |
// and checking the invariant that threads and locks |
|
392 |
// are in a 1/N relation, with some some locks unowned. |
|
393 |
// It uses the Mutex::_owner, Mutex::_next, and |
|
394 |
// Thread::_owned_locks fields, and no other function |
|
395 |
// changes those fields. |
|
396 |
// It is illegal to set the mutex from one non-NULL |
|
397 |
// owner to another--it must be owned by NULL as an |
|
398 |
// intermediate state. |
|
399 |
||
400 |
if (new_owner != NULL) { |
|
401 |
// the thread is acquiring this lock |
|
402 |
||
403 |
assert(new_owner == Thread::current(), "Should I be doing this?"); |
|
404 |
assert(_owner == NULL, "setting the owner thread of an already owned mutex"); |
|
405 |
_owner = new_owner; // set the owner |
|
406 |
||
407 |
// link "this" into the owned locks list |
|
408 |
||
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
409 |
#ifdef ASSERT // Thread::_owned_locks is under the same ifdef |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
410 |
Monitor* locks = get_least_ranked_lock(new_owner->owned_locks()); |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
411 |
// Mutex::set_owner_implementation is a friend of Thread |
1 | 412 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
413 |
assert(this->rank() >= 0, "bad lock rank"); |
1 | 414 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
415 |
// Deadlock avoidance rules require us to acquire Mutexes only in |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
416 |
// a global total order. For example m1 is the lowest ranked mutex |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
417 |
// that the thread holds and m2 is the mutex the thread is trying |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
418 |
// to acquire, then deadlock avoidance rules require that the rank |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
419 |
// of m2 be less than the rank of m1. |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
420 |
// The rank Mutex::native is an exception in that it is not subject |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
421 |
// to the verification rules. |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
422 |
if (this->rank() != Mutex::native && |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
423 |
this->rank() != Mutex::suspend_resume && |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
424 |
locks != NULL && locks->rank() <= this->rank() && |
53775 | 425 |
!SafepointSynchronize::is_at_safepoint()) { |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
426 |
new_owner->print_owned_locks(); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
427 |
fatal("acquiring lock %s/%d out of order with lock %s/%d -- " |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
428 |
"possible deadlock", this->name(), this->rank(), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
429 |
locks->name(), locks->rank()); |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
430 |
} |
1 | 431 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
432 |
this->_next = new_owner->_owned_locks; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
433 |
new_owner->_owned_locks = this; |
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
434 |
#endif |
1 | 435 |
|
436 |
} else { |
|
437 |
// the thread is releasing this lock |
|
438 |
||
439 |
Thread* old_owner = _owner; |
|
52555
3b2d22602c16
8213708: Different #ifdef guards cause incorrect use of Monitor::check_block_state()
pchilanomate
parents:
52450
diff
changeset
|
440 |
DEBUG_ONLY(_last_owner = old_owner;) |
1 | 441 |
|
442 |
assert(old_owner != NULL, "removing the owner thread of an unowned mutex"); |
|
443 |
assert(old_owner == Thread::current(), "removing the owner thread of an unowned mutex"); |
|
444 |
||
445 |
_owner = NULL; // set the owner |
|
446 |
||
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
447 |
#ifdef ASSERT |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
448 |
Monitor *locks = old_owner->owned_locks(); |
1 | 449 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
450 |
// remove "this" from the owned locks list |
1 | 451 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
452 |
Monitor *prev = NULL; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
453 |
bool found = false; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
454 |
for (; locks != NULL; prev = locks, locks = locks->next()) { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
455 |
if (locks == this) { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
456 |
found = true; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
457 |
break; |
1 | 458 |
} |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
459 |
} |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
460 |
assert(found, "Removing a lock not owned"); |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
461 |
if (prev == NULL) { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
462 |
old_owner->_owned_locks = _next; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
463 |
} else { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
464 |
prev->_next = _next; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
465 |
} |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
466 |
_next = NULL; |
26684
d1221849ea3d
8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
26683
diff
changeset
|
467 |
#endif |
1 | 468 |
} |
469 |
} |
|
470 |
||
471 |
||
472 |
// Factored out common sanity checks for locking mutex'es. Used by lock() and try_lock() |
|
50280
5aaf3a471172
8203817: Monitor::try_lock() should not call check_prelock_state()
pliden
parents:
50203
diff
changeset
|
473 |
void Monitor::check_prelock_state(Thread *thread, bool safepoint_check) { |
5aaf3a471172
8203817: Monitor::try_lock() should not call check_prelock_state()
pliden
parents:
50203
diff
changeset
|
474 |
if (safepoint_check) { |
5aaf3a471172
8203817: Monitor::try_lock() should not call check_prelock_state()
pliden
parents:
50203
diff
changeset
|
475 |
assert((!thread->is_Java_thread() || ((JavaThread *)thread)->thread_state() == _thread_in_vm) |
5aaf3a471172
8203817: Monitor::try_lock() should not call check_prelock_state()
pliden
parents:
50203
diff
changeset
|
476 |
|| rank() == Mutex::special, "wrong thread state for using locks"); |
1 | 477 |
if (thread->is_VM_thread() && !allow_vm_block()) { |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
478 |
fatal("VM thread using lock %s (not allowed to block on)", name()); |
1 | 479 |
} |
52555
3b2d22602c16
8213708: Different #ifdef guards cause incorrect use of Monitor::check_block_state()
pchilanomate
parents:
52450
diff
changeset
|
480 |
DEBUG_ONLY(if (rank() != Mutex::special) \ |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
481 |
thread->check_for_valid_safepoint_state(false);) |
1 | 482 |
} |
46644
a5813fb66270
8183925: Decouple crash protection from watcher thread
rehn
parents:
41704
diff
changeset
|
483 |
assert(!os::ThreadCrashProtection::is_crash_protected(thread), |
a5813fb66270
8183925: Decouple crash protection from watcher thread
rehn
parents:
41704
diff
changeset
|
484 |
"locking not allowed when crash protection is set"); |
1 | 485 |
} |
486 |
||
487 |
void Monitor::check_block_state(Thread *thread) { |
|
488 |
if (!_allow_vm_block && thread->is_VM_thread()) { |
|
489 |
warning("VM thread blocked on lock"); |
|
490 |
print(); |
|
491 |
BREAKPOINT; |
|
492 |
} |
|
493 |
assert(_owner != thread, "deadlock: blocking on monitor owned by current thread"); |
|
494 |
} |
|
495 |
||
496 |
#endif // PRODUCT |