author | bulasevich |
Wed, 20 Nov 2019 09:29:23 +0300 | |
changeset 59143 | 1037c4d14378 |
parent 58454 | d873ce07465d |
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 |
|
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
35 |
#ifdef ASSERT |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
36 |
void Mutex::check_block_state(Thread* thread) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
37 |
if (!_allow_vm_block && thread->is_VM_thread()) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
38 |
// JavaThreads are checked to make sure that they do not hold _allow_vm_block locks during operations |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
39 |
// that could safepoint. Make sure the vm thread never uses locks with _allow_vm_block == false. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
40 |
fatal("VM thread could block on lock that may be held by a JavaThread during safepoint: %s", name()); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
41 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
42 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
43 |
assert(!os::ThreadCrashProtection::is_crash_protected(thread), |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
44 |
"locking not allowed when crash protection is set"); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
45 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
46 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
47 |
void Mutex::check_safepoint_state(Thread* thread) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
48 |
check_block_state(thread); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
49 |
|
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
50 |
// If the JavaThread checks for safepoint, verify that the lock wasn't created with safepoint_check_never. |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
51 |
if (thread->is_active_Java_thread()) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
52 |
assert(_safepoint_check_required != _safepoint_check_never, |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
53 |
"This lock should %s have a safepoint check for Java threads: %s", |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
54 |
_safepoint_check_required ? "always" : "never", name()); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
55 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
56 |
// Also check NoSafepointVerifier, and thread state is _thread_in_vm |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
57 |
thread->check_for_valid_safepoint_state(); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
58 |
} else { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
59 |
// If initialized with safepoint_check_never, a NonJavaThread should never ask to safepoint check either. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
60 |
assert(_safepoint_check_required != _safepoint_check_never, |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
61 |
"NonJavaThread should not check for safepoint"); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
62 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
63 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
64 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
65 |
void Mutex::check_no_safepoint_state(Thread* thread) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
66 |
check_block_state(thread); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
67 |
assert(!thread->is_active_Java_thread() || _safepoint_check_required != _safepoint_check_always, |
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
68 |
"This lock should %s have a safepoint check for Java threads: %s", |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
69 |
_safepoint_check_required ? "always" : "never", name()); |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
70 |
} |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
71 |
#endif // ASSERT |
1 | 72 |
|
58454 | 73 |
void Mutex::lock_contended(Thread* self) { |
74 |
Mutex *in_flight_mutex = NULL; |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
75 |
DEBUG_ONLY(int retry_cnt = 0;) |
57699
4aea554692aa
8226228: Make Threads_lock an always safepoint checked lock.
rehn
parents:
57668
diff
changeset
|
76 |
bool is_active_Java_thread = self->is_active_Java_thread(); |
58454 | 77 |
do { |
78 |
#ifdef ASSERT |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
79 |
if (retry_cnt++ > 3) { |
57840 | 80 |
log_trace(vmmutex)("JavaThread " INTPTR_FORMAT " on %d attempt trying to acquire vmmutex %s", p2i(self), retry_cnt, _name); |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
81 |
} |
58454 | 82 |
#endif // ASSERT |
1 | 83 |
|
57699
4aea554692aa
8226228: Make Threads_lock an always safepoint checked lock.
rehn
parents:
57668
diff
changeset
|
84 |
// Is it a JavaThread participating in the safepoint protocol. |
4aea554692aa
8226228: Make Threads_lock an always safepoint checked lock.
rehn
parents:
57668
diff
changeset
|
85 |
if (is_active_Java_thread) { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
86 |
assert(rank() > Mutex::special, "Potential deadlock with special or lesser rank mutex"); |
57840 | 87 |
{ ThreadBlockInVMWithDeadlockCheck tbivmdc((JavaThread *) self, &in_flight_mutex); |
88 |
in_flight_mutex = this; // save for ~ThreadBlockInVMWithDeadlockCheck |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
89 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
90 |
} |
57840 | 91 |
if (in_flight_mutex != NULL) { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
92 |
// Not unlocked by ~ThreadBlockInVMWithDeadlockCheck |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
93 |
break; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
94 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
95 |
} else { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
96 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
97 |
break; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
98 |
} |
58454 | 99 |
} while (!_lock.try_lock()); |
100 |
} |
|
101 |
||
102 |
void Mutex::lock(Thread* self) { |
|
103 |
check_safepoint_state(self); |
|
104 |
||
105 |
assert(_owner != self, "invariant"); |
|
106 |
||
107 |
if (!_lock.try_lock()) { |
|
108 |
// The lock is contended, use contended slow-path function to lock |
|
109 |
lock_contended(self); |
|
1 | 110 |
} |
111 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
112 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
113 |
set_owner(self); |
1 | 114 |
} |
115 |
||
57840 | 116 |
void Mutex::lock() { |
58454 | 117 |
lock(Thread::current()); |
1 | 118 |
} |
119 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
120 |
// 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
|
121 |
// 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
|
122 |
// 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
|
123 |
// 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
|
124 |
// in the wrong way this can lead to a deadlock with the safepoint code. |
1 | 125 |
|
57840 | 126 |
void Mutex::lock_without_safepoint_check(Thread * self) { |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
127 |
check_no_safepoint_state(self); |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
128 |
assert(_owner != self, "invariant"); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
129 |
_lock.lock(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
130 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
131 |
set_owner(self); |
1 | 132 |
} |
133 |
||
57840 | 134 |
void Mutex::lock_without_safepoint_check() { |
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
135 |
lock_without_safepoint_check(Thread::current()); |
1 | 136 |
} |
137 |
||
138 |
||
22551 | 139 |
// Returns true if thread succeeds in grabbing the lock, otherwise false. |
1 | 140 |
|
57840 | 141 |
bool Mutex::try_lock() { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
142 |
Thread * const self = Thread::current(); |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
143 |
// Some safepoint_check_always locks use try_lock, so cannot check |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
144 |
// safepoint state, but can check blocking state. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
145 |
check_block_state(self); |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
146 |
if (_lock.try_lock()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
147 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
148 |
set_owner(self); |
1 | 149 |
return true; |
150 |
} |
|
151 |
return false; |
|
152 |
} |
|
153 |
||
57840 | 154 |
void Mutex::release_for_safepoint() { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
155 |
assert_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
156 |
_lock.unlock(); |
1 | 157 |
} |
158 |
||
57840 | 159 |
void Mutex::unlock() { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
160 |
assert_owner(Thread::current()); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
161 |
set_owner(NULL); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
162 |
_lock.unlock(); |
1 | 163 |
} |
164 |
||
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
165 |
void Monitor::notify() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
166 |
assert_owner(Thread::current()); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
167 |
_lock.notify(); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
168 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
169 |
|
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
170 |
void Monitor::notify_all() { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
171 |
assert_owner(Thread::current()); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
172 |
_lock.notify_all(); |
1 | 173 |
} |
174 |
||
54495
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
175 |
#ifdef ASSERT |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
176 |
void Monitor::assert_wait_lock_state(Thread* self) { |
57840 | 177 |
Mutex* 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
|
178 |
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
|
179 |
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
|
180 |
::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
|
181 |
" lock %s/%d -- possible deadlock", |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
182 |
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
|
183 |
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
|
184 |
} |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
185 |
} |
54495
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
186 |
#endif // ASSERT |
941db9c0b5b5
8222231: Clean up interfaceSupport.inline.hpp duplicated code
coleenp
parents:
53775
diff
changeset
|
187 |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
188 |
bool Monitor::wait_without_safepoint_check(long timeout) { |
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
189 |
Thread* const self = Thread::current(); |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
190 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
191 |
// timeout is in milliseconds - with zero meaning never timeout |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
192 |
assert(timeout >= 0, "negative timeout"); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
193 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
194 |
assert_owner(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
195 |
assert_wait_lock_state(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
196 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
197 |
// conceptually set the owner to NULL in anticipation of |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
198 |
// abdicating the lock in wait |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
199 |
set_owner(NULL); |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
200 |
// Check safepoint state after resetting owner and possible NSV. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
201 |
check_no_safepoint_state(self); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
202 |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
203 |
int wait_status = _lock.wait(timeout); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
204 |
set_owner(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
205 |
return wait_status != 0; // return true IFF timeout |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
206 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
207 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
208 |
bool Monitor::wait(long timeout, bool as_suspend_equivalent) { |
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
209 |
Thread* const self = Thread::current(); |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
210 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
211 |
// timeout is in milliseconds - with zero meaning never timeout |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
212 |
assert(timeout >= 0, "negative timeout"); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
213 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
214 |
assert_owner(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
215 |
|
57699
4aea554692aa
8226228: Make Threads_lock an always safepoint checked lock.
rehn
parents:
57668
diff
changeset
|
216 |
// Safepoint checking logically implies an active JavaThread. |
4aea554692aa
8226228: Make Threads_lock an always safepoint checked lock.
rehn
parents:
57668
diff
changeset
|
217 |
guarantee(self->is_active_Java_thread(), "invariant"); |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
218 |
assert_wait_lock_state(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
219 |
|
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
220 |
int wait_status; |
1 | 221 |
// conceptually set the owner to NULL in anticipation of |
222 |
// abdicating the lock in wait |
|
223 |
set_owner(NULL); |
|
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
224 |
// Check safepoint state after resetting owner and possible NSV. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
225 |
check_safepoint_state(self); |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
226 |
JavaThread *jt = (JavaThread *)self; |
57840 | 227 |
Mutex* in_flight_mutex = NULL; |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
228 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
229 |
{ |
57840 | 230 |
ThreadBlockInVMWithDeadlockCheck tbivmdc(jt, &in_flight_mutex); |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
231 |
OSThreadWaitState osts(self->osthread(), false /* not Object.wait() */); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
232 |
if (as_suspend_equivalent) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
233 |
jt->set_suspend_equivalent(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
234 |
// cleared by handle_special_suspend_equivalent_condition() or |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
235 |
// java_suspend_self() |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
236 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
237 |
|
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
238 |
wait_status = _lock.wait(timeout); |
57840 | 239 |
in_flight_mutex = this; // save for ~ThreadBlockInVMWithDeadlockCheck |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
240 |
|
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
241 |
// were we externally suspended while we were waiting? |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
242 |
if (as_suspend_equivalent && jt->handle_special_suspend_equivalent_condition()) { |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
243 |
// Our event wait has finished and we own the lock, but |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
244 |
// while we were waiting another thread suspended us. We don't |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
245 |
// want to hold the lock while suspended because that |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
246 |
// would surprise the thread that suspended us. |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
247 |
_lock.unlock(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
248 |
jt->java_suspend_self(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
249 |
_lock.lock(); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
250 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
251 |
} |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
252 |
|
57840 | 253 |
if (in_flight_mutex != NULL) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
254 |
// Not unlocked by ~ThreadBlockInVMWithDeadlockCheck |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
255 |
assert_owner(NULL); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
256 |
// Conceptually reestablish ownership of the lock. |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
257 |
set_owner(self); |
1 | 258 |
} else { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
259 |
lock(self); |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54495
diff
changeset
|
260 |
} |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
261 |
|
25069
c937c5e883c5
8047156: cleanup more non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents:
24424
diff
changeset
|
262 |
return wait_status != 0; // return true IFF timeout |
1 | 263 |
} |
264 |
||
57840 | 265 |
Mutex::~Mutex() { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
266 |
assert_owner(NULL); |
1 | 267 |
} |
268 |
||
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
269 |
// Only Threads_lock, Heap_lock and SR_lock may be safepoint_check_sometimes. |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
270 |
bool is_sometimes_ok(const char* name) { |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
271 |
return (strcmp(name, "Threads_lock") == 0 || strcmp(name, "Heap_lock") == 0 || strcmp(name, "SR_lock") == 0); |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
272 |
} |
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
273 |
|
57840 | 274 |
Mutex::Mutex(int Rank, const char * name, bool allow_vm_block, |
275 |
SafepointCheckRequired safepoint_check_required) : _owner(NULL) { |
|
52581
d402a406bbc3
8213723: More Monitor/mutex initialization management
dholmes
parents:
52555
diff
changeset
|
276 |
assert(os::mutex_init_done(), "Too early!"); |
57668 | 277 |
if (name == NULL) { |
278 |
strcpy(_name, "UNKNOWN"); |
|
279 |
} else { |
|
57840 | 280 |
strncpy(_name, name, MUTEX_NAME_LEN - 1); |
281 |
_name[MUTEX_NAME_LEN - 1] = '\0'; |
|
57668 | 282 |
} |
1 | 283 |
#ifdef ASSERT |
284 |
_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
|
285 |
_rank = Rank; |
57668 | 286 |
_safepoint_check_required = safepoint_check_required; |
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
287 |
|
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
288 |
assert(_safepoint_check_required != _safepoint_check_sometimes || is_sometimes_ok(name), |
54663
f03d5a093093
8074355: make MutexLocker smarter about non-JavaThreads
coleenp
parents:
54623
diff
changeset
|
289 |
"Lock has _safepoint_check_sometimes %s", name); |
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
290 |
|
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
291 |
assert(_rank > special || _safepoint_check_required == _safepoint_check_never, |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
292 |
"Special locks or below should never safepoint"); |
1 | 293 |
#endif |
294 |
} |
|
295 |
||
57840 | 296 |
Monitor::Monitor(int Rank, const char * name, bool allow_vm_block, |
57668 | 297 |
SafepointCheckRequired safepoint_check_required) : |
57840 | 298 |
Mutex(Rank, name, allow_vm_block, safepoint_check_required) {} |
1 | 299 |
|
57840 | 300 |
bool Mutex::owned_by_self() const { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
301 |
return _owner == Thread::current(); |
1 | 302 |
} |
303 |
||
57840 | 304 |
void Mutex::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
|
305 |
st->print("[" PTR_FORMAT, p2i(this)); |
1 | 306 |
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
|
307 |
st->print(" - owner thread: " PTR_FORMAT, p2i(_owner)); |
1 | 308 |
} |
309 |
||
310 |
// ---------------------------------------------------------------------------------- |
|
311 |
// Non-product code |
|
312 |
||
313 |
#ifndef PRODUCT |
|
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
314 |
const char* print_safepoint_check(Mutex::SafepointCheckRequired safepoint_check) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
315 |
switch (safepoint_check) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
316 |
case Mutex::_safepoint_check_never: return "safepoint_check_never"; |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
317 |
case Mutex::_safepoint_check_sometimes: return "safepoint_check_sometimes"; |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
318 |
case Mutex::_safepoint_check_always: return "safepoint_check_always"; |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
319 |
default: return ""; |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
320 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
321 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
322 |
|
57840 | 323 |
void Mutex::print_on(outputStream* st) const { |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
324 |
st->print("Mutex: [" PTR_FORMAT "] %s - owner: " PTR_FORMAT, |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
325 |
p2i(this), _name, p2i(_owner)); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
326 |
if (_allow_vm_block) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
327 |
st->print("%s", " allow_vm_block"); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
328 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
329 |
st->print(" %s", print_safepoint_check(_safepoint_check_required)); |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
330 |
st->cr(); |
1 | 331 |
} |
332 |
#endif |
|
333 |
||
334 |
#ifdef ASSERT |
|
57840 | 335 |
void Mutex::assert_owner(Thread * expected) { |
53646
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
336 |
const char* msg = "invalid owner"; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
337 |
if (expected == NULL) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
338 |
msg = "should be un-owned"; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
339 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
340 |
else if (expected == Thread::current()) { |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
341 |
msg = "should be owned by current thread"; |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
342 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
343 |
assert(_owner == expected, |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
344 |
"%s: owner=" INTPTR_FORMAT ", should be=" INTPTR_FORMAT, |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
345 |
msg, p2i(_owner), p2i(expected)); |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
346 |
} |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
347 |
|
57840 | 348 |
Mutex* Mutex::get_least_ranked_lock(Mutex* locks) { |
349 |
Mutex *res, *tmp; |
|
1 | 350 |
for (res = tmp = locks; tmp != NULL; tmp = tmp->next()) { |
351 |
if (tmp->rank() < res->rank()) { |
|
352 |
res = tmp; |
|
353 |
} |
|
354 |
} |
|
355 |
if (!SafepointSynchronize::is_at_safepoint()) { |
|
356 |
// In this case, we expect the held locks to be |
|
357 |
// in increasing rank order (modulo any native ranks) |
|
358 |
for (tmp = locks; tmp != NULL; tmp = tmp->next()) { |
|
359 |
if (tmp->next() != NULL) { |
|
360 |
assert(tmp->rank() == Mutex::native || |
|
361 |
tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?"); |
|
362 |
} |
|
363 |
} |
|
364 |
} |
|
365 |
return res; |
|
366 |
} |
|
367 |
||
57840 | 368 |
Mutex* Mutex::get_least_ranked_lock_besides_this(Mutex* locks) { |
369 |
Mutex *res, *tmp; |
|
1 | 370 |
for (res = NULL, tmp = locks; tmp != NULL; tmp = tmp->next()) { |
371 |
if (tmp != this && (res == NULL || tmp->rank() < res->rank())) { |
|
372 |
res = tmp; |
|
373 |
} |
|
374 |
} |
|
375 |
if (!SafepointSynchronize::is_at_safepoint()) { |
|
376 |
// In this case, we expect the held locks to be |
|
377 |
// in increasing rank order (modulo any native ranks) |
|
378 |
for (tmp = locks; tmp != NULL; tmp = tmp->next()) { |
|
379 |
if (tmp->next() != NULL) { |
|
380 |
assert(tmp->rank() == Mutex::native || |
|
381 |
tmp->rank() <= tmp->next()->rank(), "mutex rank anomaly?"); |
|
382 |
} |
|
383 |
} |
|
384 |
} |
|
385 |
return res; |
|
386 |
} |
|
387 |
||
57840 | 388 |
bool Mutex::contains(Mutex* locks, Mutex* lock) { |
1 | 389 |
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
|
390 |
if (locks == lock) { |
1 | 391 |
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
|
392 |
} |
1 | 393 |
} |
394 |
return false; |
|
395 |
} |
|
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
396 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
397 |
// NSV implied with locking allow_vm_block or !safepoint_check locks. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
398 |
void Mutex::no_safepoint_verifier(Thread* thread, bool enable) { |
58409
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
399 |
// The tty_lock is special because it is released for the safepoint by |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
400 |
// the safepoint mechanism. |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
401 |
if (this == tty_lock) { |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
402 |
return; |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
403 |
} |
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
404 |
|
a595e67d6683
8184732: Deadlock detection improvements for 'special' locks
coleenp
parents:
58291
diff
changeset
|
405 |
if (_allow_vm_block) { |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
406 |
if (enable) { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
407 |
thread->_no_safepoint_count++; |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
408 |
} else { |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
409 |
thread->_no_safepoint_count--; |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
410 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
411 |
} |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
412 |
} |
1 | 413 |
|
414 |
// Called immediately after lock acquisition or release as a diagnostic |
|
415 |
// to track the lock-set of the thread and test for rank violations that |
|
416 |
// might indicate exposure to deadlock. |
|
417 |
// Rather like an EventListener for _owner (:>). |
|
418 |
||
57840 | 419 |
void Mutex::set_owner_implementation(Thread *new_owner) { |
1 | 420 |
// This function is solely responsible for maintaining |
421 |
// and checking the invariant that threads and locks |
|
422 |
// are in a 1/N relation, with some some locks unowned. |
|
423 |
// It uses the Mutex::_owner, Mutex::_next, and |
|
424 |
// Thread::_owned_locks fields, and no other function |
|
425 |
// changes those fields. |
|
426 |
// It is illegal to set the mutex from one non-NULL |
|
427 |
// owner to another--it must be owned by NULL as an |
|
428 |
// intermediate state. |
|
429 |
||
430 |
if (new_owner != NULL) { |
|
431 |
// the thread is acquiring this lock |
|
432 |
||
433 |
assert(new_owner == Thread::current(), "Should I be doing this?"); |
|
434 |
assert(_owner == NULL, "setting the owner thread of an already owned mutex"); |
|
435 |
_owner = new_owner; // set the owner |
|
436 |
||
437 |
// link "this" into the owned locks list |
|
438 |
||
57840 | 439 |
Mutex* locks = get_least_ranked_lock(new_owner->owned_locks()); |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
440 |
// Mutex::set_owner_implementation is a friend of Thread |
1 | 441 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
442 |
assert(this->rank() >= 0, "bad lock rank"); |
1 | 443 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
444 |
// 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
|
445 |
// 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
|
446 |
// 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
|
447 |
// to acquire, then deadlock avoidance rules require that the rank |
043ae846819f
8210832: Remove sneaky locking in class Monitor
pchilanomate
parents:
52913
diff
changeset
|
448 |
// 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
|
449 |
// 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
|
450 |
// 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
|
451 |
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
|
452 |
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
|
453 |
locks != NULL && locks->rank() <= this->rank() && |
53775 | 454 |
!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
|
455 |
new_owner->print_owned_locks(); |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
456 |
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
|
457 |
"possible deadlock", this->name(), this->rank(), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
28163
diff
changeset
|
458 |
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
|
459 |
} |
1 | 460 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
461 |
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
|
462 |
new_owner->_owned_locks = this; |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
463 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
464 |
// NSV implied with locking allow_vm_block flag. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
465 |
no_safepoint_verifier(new_owner, true); |
1 | 466 |
|
467 |
} else { |
|
468 |
// the thread is releasing this lock |
|
469 |
||
470 |
Thread* old_owner = _owner; |
|
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
471 |
_last_owner = old_owner; |
1 | 472 |
|
473 |
assert(old_owner != NULL, "removing the owner thread of an unowned mutex"); |
|
474 |
assert(old_owner == Thread::current(), "removing the owner thread of an unowned mutex"); |
|
475 |
||
476 |
_owner = NULL; // set the owner |
|
477 |
||
57840 | 478 |
Mutex* locks = old_owner->owned_locks(); |
1 | 479 |
|
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
480 |
// remove "this" from the owned locks list |
1 | 481 |
|
57840 | 482 |
Mutex* prev = NULL; |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
483 |
bool found = false; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
484 |
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
|
485 |
if (locks == this) { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
486 |
found = true; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
487 |
break; |
1 | 488 |
} |
26683
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
489 |
} |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
490 |
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
|
491 |
if (prev == NULL) { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
492 |
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
|
493 |
} else { |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
494 |
prev->_next = _next; |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
495 |
} |
a02753d5a0b2
8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents:
25472
diff
changeset
|
496 |
_next = NULL; |
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
497 |
|
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
498 |
// ~NSV implied with locking allow_vm_block flag. |
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
499 |
no_safepoint_verifier(old_owner, false); |
1 | 500 |
} |
501 |
} |
|
58291
a013100f7a35
8213150: Add verification for locking by VMThread
coleenp
parents:
57840
diff
changeset
|
502 |
#endif // ASSERT |