author | mr |
Tue, 29 Oct 2019 13:52:04 -0700 | |
changeset 58850 | f4290bf1cc21 |
parent 58226 | 408c445d04e8 |
child 58679 | 9c3209ff7550 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
49364
diff
changeset
|
2 |
* Copyright (c) 2005, 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:
1
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1
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:
1
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
49364
diff
changeset
|
25 |
#ifndef SHARE_RUNTIME_BIASEDLOCKING_HPP |
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
49364
diff
changeset
|
26 |
#define SHARE_RUNTIME_BIASEDLOCKING_HPP |
7397 | 27 |
|
28 |
#include "runtime/handles.hpp" |
|
29 |
#include "utilities/growableArray.hpp" |
|
30 |
||
1 | 31 |
// This class describes operations to implement Store-Free Biased |
32 |
// Locking. The high-level properties of the scheme are similar to |
|
33 |
// IBM's lock reservation, Dice-Moir-Scherer QR locks, and other biased |
|
34 |
// locking mechanisms. The principal difference is in the handling of |
|
35 |
// recursive locking which is how this technique achieves a more |
|
36 |
// efficient fast path than these other schemes. |
|
37 |
// |
|
38 |
// The basic observation is that in HotSpot's current fast locking |
|
39 |
// scheme, recursive locking (in the fast path) causes no update to |
|
40 |
// the object header. The recursion is described simply by stack |
|
41 |
// records containing a specific value (NULL). Only the last unlock by |
|
42 |
// a given thread causes an update to the object header. |
|
43 |
// |
|
44 |
// This observation, coupled with the fact that HotSpot only compiles |
|
45 |
// methods for which monitor matching is obeyed (and which therefore |
|
46 |
// can not throw IllegalMonitorStateException), implies that we can |
|
47 |
// completely eliminate modifications to the object header for |
|
48 |
// recursive locking in compiled code, and perform similar recursion |
|
49 |
// checks and throwing of IllegalMonitorStateException in the |
|
50 |
// interpreter with little or no impact on the performance of the fast |
|
51 |
// path. |
|
52 |
// |
|
53 |
// The basic algorithm is as follows (note, see below for more details |
|
54 |
// and information). A pattern in the low three bits is reserved in |
|
55 |
// the object header to indicate whether biasing of a given object's |
|
56 |
// lock is currently being done or is allowed at all. If the bias |
|
57 |
// pattern is present, the contents of the rest of the header are |
|
58 |
// either the JavaThread* of the thread to which the lock is biased, |
|
59 |
// or NULL, indicating that the lock is "anonymously biased". The |
|
60 |
// first thread which locks an anonymously biased object biases the |
|
61 |
// lock toward that thread. If another thread subsequently attempts to |
|
62 |
// lock the same object, the bias is revoked. |
|
63 |
// |
|
64 |
// Because there are no updates to the object header at all during |
|
65 |
// recursive locking while the lock is biased, the biased lock entry |
|
66 |
// code is simply a test of the object header's value. If this test |
|
67 |
// succeeds, the lock has been acquired by the thread. If this test |
|
68 |
// fails, a bit test is done to see whether the bias bit is still |
|
69 |
// set. If not, we fall back to HotSpot's original CAS-based locking |
|
70 |
// scheme. If it is set, we attempt to CAS in a bias toward this |
|
71 |
// thread. The latter operation is expected to be the rarest operation |
|
72 |
// performed on these locks. We optimistically expect the biased lock |
|
73 |
// entry to hit most of the time, and want the CAS-based fallthrough |
|
74 |
// to occur quickly in the situations where the bias has been revoked. |
|
75 |
// |
|
76 |
// Revocation of the lock's bias is fairly straightforward. We want to |
|
77 |
// restore the object's header and stack-based BasicObjectLocks and |
|
78 |
// BasicLocks to the state they would have been in had the object been |
|
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
79 |
// locked by HotSpot's usual fast locking scheme. To do this, we execute |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
80 |
// a handshake with the JavaThread that biased the lock. Inside the |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
81 |
// handshake we walk the biaser stack searching for all of the lock |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
82 |
// records corresponding to this object, in particular the first / "highest" |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
83 |
// record. We fill in the highest lock record with the object's displaced |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
84 |
// header (which is a well-known value given that we don't maintain an |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
85 |
// identity hash nor age bits for the object while it's in the biased |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
86 |
// state) and all other lock records with 0, the value for recursive locks. |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
87 |
// Alternatively, we can revoke the bias of an object inside a safepoint |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
88 |
// if we are already in one and we detect that we need to perform a |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
89 |
// revocation. |
1 | 90 |
// |
91 |
// This scheme can not handle transfers of biases of single objects |
|
92 |
// from thread to thread efficiently, but it can handle bulk transfers |
|
93 |
// of such biases, which is a usage pattern showing up in some |
|
94 |
// applications and benchmarks. We implement "bulk rebias" and "bulk |
|
95 |
// revoke" operations using a "bias epoch" on a per-data-type basis. |
|
96 |
// If too many bias revocations are occurring for a particular data |
|
97 |
// type, the bias epoch for the data type is incremented at a |
|
98 |
// safepoint, effectively meaning that all previous biases are |
|
99 |
// invalid. The fast path locking case checks for an invalid epoch in |
|
100 |
// the object header and attempts to rebias the object with a CAS if |
|
101 |
// found, avoiding safepoints or bulk heap sweeps (the latter which |
|
102 |
// was used in a prior version of this algorithm and did not scale |
|
103 |
// well). If too many bias revocations persist, biasing is completely |
|
104 |
// disabled for the data type by resetting the prototype header to the |
|
57777
90ead0febf56
8229258: Rework markOop and markOopDesc into a simpler mark word value carrier
stefank
parents:
55625
diff
changeset
|
105 |
// unbiased markWord. The fast-path locking code checks to see whether |
1 | 106 |
// the instance's bias pattern differs from the prototype header's and |
107 |
// causes the bias to be revoked without reaching a safepoint or, |
|
108 |
// again, a bulk heap sweep. |
|
109 |
||
110 |
// Biased locking counters |
|
49364
601146c66cad
8173070: Remove ValueObj class for allocation subclassing for runtime code
coleenp
parents:
47216
diff
changeset
|
111 |
class BiasedLockingCounters { |
1 | 112 |
private: |
113 |
int _total_entry_count; |
|
114 |
int _biased_lock_entry_count; |
|
115 |
int _anonymously_biased_lock_entry_count; |
|
116 |
int _rebiased_lock_entry_count; |
|
117 |
int _revoked_lock_entry_count; |
|
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
118 |
int _handshakes_count; |
1 | 119 |
int _fast_path_entry_count; |
120 |
int _slow_path_entry_count; |
|
121 |
||
122 |
public: |
|
123 |
BiasedLockingCounters() : |
|
124 |
_total_entry_count(0), |
|
125 |
_biased_lock_entry_count(0), |
|
126 |
_anonymously_biased_lock_entry_count(0), |
|
127 |
_rebiased_lock_entry_count(0), |
|
128 |
_revoked_lock_entry_count(0), |
|
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
129 |
_handshakes_count(0), |
1 | 130 |
_fast_path_entry_count(0), |
131 |
_slow_path_entry_count(0) {} |
|
132 |
||
54807 | 133 |
int slow_path_entry_count() const; // Compute this field if necessary |
1 | 134 |
|
135 |
int* total_entry_count_addr() { return &_total_entry_count; } |
|
136 |
int* biased_lock_entry_count_addr() { return &_biased_lock_entry_count; } |
|
137 |
int* anonymously_biased_lock_entry_count_addr() { return &_anonymously_biased_lock_entry_count; } |
|
138 |
int* rebiased_lock_entry_count_addr() { return &_rebiased_lock_entry_count; } |
|
139 |
int* revoked_lock_entry_count_addr() { return &_revoked_lock_entry_count; } |
|
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
140 |
int* handshakes_count_addr() { return &_handshakes_count; } |
1 | 141 |
int* fast_path_entry_count_addr() { return &_fast_path_entry_count; } |
142 |
int* slow_path_entry_count_addr() { return &_slow_path_entry_count; } |
|
143 |
||
144 |
bool nonzero() { return _total_entry_count > 0; } |
|
145 |
||
54807 | 146 |
void print_on(outputStream* st) const; |
147 |
void print() const; |
|
1 | 148 |
}; |
149 |
||
150 |
||
151 |
class BiasedLocking : AllStatic { |
|
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
152 |
friend class VM_BulkRevokeBias; |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
153 |
friend class RevokeOneBias; |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
154 |
|
1 | 155 |
private: |
156 |
static BiasedLockingCounters _counters; |
|
157 |
||
158 |
public: |
|
159 |
static int* total_entry_count_addr(); |
|
160 |
static int* biased_lock_entry_count_addr(); |
|
161 |
static int* anonymously_biased_lock_entry_count_addr(); |
|
162 |
static int* rebiased_lock_entry_count_addr(); |
|
163 |
static int* revoked_lock_entry_count_addr(); |
|
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
164 |
static int* handshakes_count_addr(); |
1 | 165 |
static int* fast_path_entry_count_addr(); |
166 |
static int* slow_path_entry_count_addr(); |
|
167 |
||
168 |
enum Condition { |
|
169 |
NOT_BIASED = 1, |
|
170 |
BIAS_REVOKED = 2, |
|
57893
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
171 |
NOT_REVOKED = 3 |
1 | 172 |
}; |
173 |
||
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
174 |
private: |
57893
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
175 |
static void single_revoke_at_safepoint(oop obj, bool is_bulk, JavaThread* requester, JavaThread** biaser); |
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
176 |
static void bulk_revoke_at_safepoint(oop o, bool bulk_rebias, JavaThread* requester); |
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
177 |
static Condition single_revoke_with_handshake(Handle obj, JavaThread *requester, JavaThread *biaser); |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
178 |
static void walk_stack_and_revoke(oop obj, JavaThread* biased_locker); |
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
179 |
|
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
180 |
public: |
1 | 181 |
// This initialization routine should only be called once and |
182 |
// schedules a PeriodicTask to turn on biased locking a few seconds |
|
183 |
// into the VM run to avoid startup time regressions |
|
184 |
static void init(); |
|
185 |
||
186 |
// This provides a global switch for leaving biased locking disabled |
|
187 |
// for the first part of a run and enabling it later |
|
188 |
static bool enabled(); |
|
189 |
||
190 |
// This should be called by JavaThreads to revoke the bias of an object |
|
57893
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
191 |
static void revoke(Handle obj, TRAPS); |
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
192 |
|
58226 | 193 |
// This must only be called by a JavaThread to revoke the bias of an owned object. |
194 |
static void revoke_own_lock(Handle obj, TRAPS); |
|
195 |
||
57893
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
196 |
static void revoke_at_safepoint(Handle obj); |
1 | 197 |
|
57893
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
198 |
// These are used by deoptimization to ensure that monitors on the stack |
49fea19f0726
8229844: Remove attempt_rebias parameter from revoke_and_rebias()
pchilanomate
parents:
57777
diff
changeset
|
199 |
// can be migrated |
55625
f7e8dbb77156
8191890: Biased locking still uses the inferior stop the world safepoint for revocation
pchilanomate
parents:
55479
diff
changeset
|
200 |
static void revoke(GrowableArray<Handle>* objs, JavaThread *biaser); |
1 | 201 |
|
202 |
static void print_counters() { _counters.print(); } |
|
203 |
static BiasedLockingCounters* counters() { return &_counters; } |
|
204 |
||
205 |
// These routines are GC-related and should not be called by end |
|
206 |
// users. GCs which do not do preservation of mark words do not need |
|
207 |
// to call these routines. |
|
208 |
static void preserve_marks(); |
|
209 |
static void restore_marks(); |
|
210 |
}; |
|
7397 | 211 |
|
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
49364
diff
changeset
|
212 |
#endif // SHARE_RUNTIME_BIASEDLOCKING_HPP |