author | kbarrett |
Sat, 19 Jan 2019 19:50:01 -0500 | |
changeset 53404 | 9ff1e6cacac3 |
parent 53102 | 35530ca3e0b2 |
child 54255 | c81fbf340ceb |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
53404 | 2 |
* Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved. |
1374 | 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:
5082
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5082
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:
5082
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
51441
2e91d927e00c
8154343: Make SATB related code available to other GCs
kbarrett
parents:
51332
diff
changeset
|
26 |
#include "gc/shared/ptrQueue.hpp" |
53404 | 27 |
#include "logging/log.hpp" |
7397 | 28 |
#include "memory/allocation.hpp" |
29 |
#include "memory/allocation.inline.hpp" |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
30 |
#include "runtime/atomic.hpp" |
7397 | 31 |
#include "runtime/mutex.hpp" |
32 |
#include "runtime/mutexLocker.hpp" |
|
53404 | 33 |
#include "runtime/orderAccess.hpp" |
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
13963
diff
changeset
|
34 |
#include "runtime/thread.inline.hpp" |
53404 | 35 |
#include "utilities/globalCounter.inline.hpp" |
1374 | 36 |
|
36354 | 37 |
#include <new> |
38 |
||
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
39 |
PtrQueue::PtrQueue(PtrQueueSet* qset, bool permanent, bool active) : |
46443 | 40 |
_qset(qset), |
41 |
_active(active), |
|
42 |
_permanent(permanent), |
|
43 |
_index(0), |
|
44 |
_capacity_in_bytes(0), |
|
45 |
_buf(NULL), |
|
46 |
_lock(NULL) |
|
1374 | 47 |
{} |
48 |
||
28507 | 49 |
PtrQueue::~PtrQueue() { |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
50 |
assert(_permanent || (_buf == NULL), "queue must be flushed before delete"); |
28507 | 51 |
} |
52 |
||
53 |
void PtrQueue::flush_impl() { |
|
46305
bff6d23aa1e3
8175221: Cleanup DirtyCardQueueSet::concatenate_log
kbarrett
parents:
37065
diff
changeset
|
54 |
if (_buf != NULL) { |
46443 | 55 |
BufferNode* node = BufferNode::make_node_from_buffer(_buf, index()); |
37065 | 56 |
if (is_empty()) { |
1374 | 57 |
// No work to do. |
37065 | 58 |
qset()->deallocate_buffer(node); |
1374 | 59 |
} else { |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
60 |
qset()->enqueue_completed_buffer(node); |
1374 | 61 |
} |
1560
1b328492b7f8
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
1374
diff
changeset
|
62 |
_buf = NULL; |
46443 | 63 |
set_index(0); |
1374 | 64 |
} |
65 |
} |
|
66 |
||
67 |
||
68 |
void PtrQueue::enqueue_known_active(void* ptr) { |
|
69 |
while (_index == 0) { |
|
70 |
handle_zero_index(); |
|
71 |
} |
|
4481 | 72 |
|
46443 | 73 |
assert(_buf != NULL, "postcondition"); |
74 |
assert(index() > 0, "postcondition"); |
|
75 |
assert(index() <= capacity(), "invariant"); |
|
76 |
_index -= _element_size; |
|
77 |
_buf[index()] = ptr; |
|
1374 | 78 |
} |
79 |
||
46443 | 80 |
BufferNode* BufferNode::allocate(size_t size) { |
81 |
size_t byte_size = size * sizeof(void*); |
|
36354 | 82 |
void* data = NEW_C_HEAP_ARRAY(char, buffer_offset() + byte_size, mtGC); |
83 |
return new (data) BufferNode; |
|
84 |
} |
|
85 |
||
86 |
void BufferNode::deallocate(BufferNode* node) { |
|
87 |
node->~BufferNode(); |
|
88 |
FREE_C_HEAP_ARRAY(char, node); |
|
89 |
} |
|
90 |
||
53404 | 91 |
BufferNode::Allocator::Allocator(const char* name, size_t buffer_size) : |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
92 |
_buffer_size(buffer_size), |
53404 | 93 |
_pending_list(), |
94 |
_free_list(), |
|
95 |
_pending_count(0), |
|
96 |
_free_count(0), |
|
97 |
_transfer_lock(false) |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
98 |
{ |
53404 | 99 |
strncpy(_name, name, sizeof(_name)); |
100 |
_name[sizeof(_name) - 1] = '\0'; |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
101 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
102 |
|
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
103 |
BufferNode::Allocator::~Allocator() { |
53404 | 104 |
delete_list(_free_list.pop_all()); |
105 |
delete_list(_pending_list.pop_all()); |
|
106 |
} |
|
107 |
||
108 |
void BufferNode::Allocator::delete_list(BufferNode* list) { |
|
109 |
while (list != NULL) { |
|
110 |
BufferNode* next = list->next(); |
|
111 |
DEBUG_ONLY(list->set_next(NULL);) |
|
112 |
BufferNode::deallocate(list); |
|
113 |
list = next; |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
114 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
115 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
116 |
|
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
117 |
size_t BufferNode::Allocator::free_count() const { |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
118 |
return Atomic::load(&_free_count); |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
119 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
120 |
|
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
121 |
BufferNode* BufferNode::Allocator::allocate() { |
53404 | 122 |
BufferNode* node; |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
123 |
{ |
53404 | 124 |
// Protect against ABA; see release(). |
125 |
GlobalCounter::CriticalSection cs(Thread::current()); |
|
126 |
node = _free_list.pop(); |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
127 |
} |
53404 | 128 |
if (node == NULL) { |
129 |
node = BufferNode::allocate(_buffer_size); |
|
130 |
} else { |
|
131 |
// Decrement count after getting buffer from free list. This, along |
|
132 |
// with incrementing count before adding to free list, ensures count |
|
133 |
// never underflows. |
|
134 |
size_t count = Atomic::sub(1u, &_free_count); |
|
135 |
assert((count + 1) != 0, "_free_count underflow"); |
|
136 |
} |
|
137 |
return node; |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
138 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
139 |
|
53404 | 140 |
// To solve the ABA problem for lock-free stack pop, allocate does the |
141 |
// pop inside a critical section, and release synchronizes on the |
|
142 |
// critical sections before adding to the _free_list. But we don't |
|
143 |
// want to make every release have to do a synchronize. Instead, we |
|
144 |
// initially place released nodes on the _pending_list, and transfer |
|
145 |
// them to the _free_list in batches. Only one transfer at a time is |
|
146 |
// permitted, with a lock bit to control access to that phase. A |
|
147 |
// transfer takes all the nodes from the _pending_list, synchronizes on |
|
148 |
// the _free_list pops, and then adds the former pending nodes to the |
|
149 |
// _free_list. While that's happening, other threads might be adding |
|
150 |
// other nodes to the _pending_list, to be dealt with by some later |
|
151 |
// transfer. |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
152 |
void BufferNode::Allocator::release(BufferNode* node) { |
53404 | 153 |
assert(node != NULL, "precondition"); |
154 |
assert(node->next() == NULL, "precondition"); |
|
155 |
||
156 |
// Desired minimum transfer batch size. There is relatively little |
|
157 |
// importance to the specific number. It shouldn't be too big, else |
|
158 |
// we're wasting space when the release rate is low. If the release |
|
159 |
// rate is high, we might accumulate more than this before being |
|
160 |
// able to start a new transfer, but that's okay. Also note that |
|
161 |
// the allocation rate and the release rate are going to be fairly |
|
162 |
// similar, due to how the buffers are used. |
|
163 |
const size_t trigger_transfer = 10; |
|
164 |
||
165 |
// Add to pending list. Update count first so no underflow in transfer. |
|
166 |
size_t pending_count = Atomic::add(1u, &_pending_count); |
|
167 |
_pending_list.push(*node); |
|
168 |
if (pending_count > trigger_transfer) { |
|
169 |
try_transfer_pending(); |
|
170 |
} |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
171 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
172 |
|
53404 | 173 |
// Try to transfer nodes from _pending_list to _free_list, with a |
174 |
// synchronization delay for any in-progress pops from the _free_list, |
|
175 |
// to solve ABA there. Return true if performed a (possibly empty) |
|
176 |
// transfer, false if blocked from doing so by some other thread's |
|
177 |
// in-progress transfer. |
|
178 |
bool BufferNode::Allocator::try_transfer_pending() { |
|
179 |
// Attempt to claim the lock. |
|
180 |
if (Atomic::load(&_transfer_lock) || // Skip CAS if likely to fail. |
|
181 |
Atomic::cmpxchg(true, &_transfer_lock, false)) { |
|
182 |
return false; |
|
183 |
} |
|
184 |
// Have the lock; perform the transfer. |
|
185 |
||
186 |
// Claim all the pending nodes. |
|
187 |
BufferNode* first = _pending_list.pop_all(); |
|
188 |
if (first != NULL) { |
|
189 |
// Prepare to add the claimed nodes, and update _pending_count. |
|
190 |
BufferNode* last = first; |
|
191 |
size_t count = 1; |
|
192 |
for (BufferNode* next = first->next(); next != NULL; next = next->next()) { |
|
193 |
last = next; |
|
194 |
++count; |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
195 |
} |
53404 | 196 |
Atomic::sub(count, &_pending_count); |
197 |
||
198 |
// Wait for any in-progress pops, to avoid ABA for them. |
|
199 |
GlobalCounter::write_synchronize(); |
|
200 |
||
201 |
// Add synchronized nodes to _free_list. |
|
202 |
// Update count first so no underflow in allocate(). |
|
203 |
Atomic::add(count, &_free_count); |
|
204 |
_free_list.prepend(*first, *last); |
|
205 |
log_trace(gc, ptrqueue, freelist) |
|
206 |
("Transferred %s pending to free: " SIZE_FORMAT, name(), count); |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
207 |
} |
53404 | 208 |
OrderAccess::release_store(&_transfer_lock, false); |
209 |
return true; |
|
210 |
} |
|
211 |
||
212 |
size_t BufferNode::Allocator::reduce_free_list(size_t remove_goal) { |
|
213 |
try_transfer_pending(); |
|
214 |
size_t removed = 0; |
|
215 |
for ( ; removed < remove_goal; ++removed) { |
|
216 |
BufferNode* node = _free_list.pop(); |
|
217 |
if (node == NULL) break; |
|
218 |
BufferNode::deallocate(node); |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
219 |
} |
53404 | 220 |
size_t new_count = Atomic::sub(removed, &_free_count); |
221 |
log_debug(gc, ptrqueue, freelist) |
|
222 |
("Reduced %s free list by " SIZE_FORMAT " to " SIZE_FORMAT, |
|
223 |
name(), removed, new_count); |
|
224 |
return removed; |
|
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
225 |
} |
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
226 |
|
1374 | 227 |
PtrQueueSet::PtrQueueSet(bool notify_when_complete) : |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
228 |
_allocator(NULL), |
51332 | 229 |
_cbl_mon(NULL), |
1374 | 230 |
_completed_buffers_head(NULL), |
231 |
_completed_buffers_tail(NULL), |
|
232 |
_n_completed_buffers(0), |
|
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
233 |
_process_completed_buffers_threshold(ProcessCompletedBuffersThresholdNever), |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
234 |
_process_completed_buffers(false), |
51332 | 235 |
_notify_when_complete(notify_when_complete), |
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
236 |
_max_completed_buffers(MaxCompletedBuffersUnlimited), |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
237 |
_completed_buffers_padding(0), |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
238 |
_all_active(false) |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
239 |
{} |
1374 | 240 |
|
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
241 |
PtrQueueSet::~PtrQueueSet() { |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
242 |
// There are presently only a couple (derived) instances ever |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
243 |
// created, and they are permanent, so no harm currently done by |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
244 |
// doing nothing here. |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
245 |
} |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
246 |
|
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
247 |
void PtrQueueSet::initialize(Monitor* cbl_mon, |
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
248 |
BufferNode::Allocator* allocator) { |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
249 |
assert(cbl_mon != NULL && allocator != NULL, "Init order issue?"); |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
250 |
_cbl_mon = cbl_mon; |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
251 |
_allocator = allocator; |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
252 |
} |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
253 |
|
1374 | 254 |
void** PtrQueueSet::allocate_buffer() { |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
255 |
BufferNode* node = _allocator->allocate(); |
36354 | 256 |
return BufferNode::make_buffer_from_node(node); |
1374 | 257 |
} |
258 |
||
37065 | 259 |
void PtrQueueSet::deallocate_buffer(BufferNode* node) { |
52582
6df094be7f58
8213352: Separate BufferNode allocation from PtrQueueSet
kbarrett
parents:
51441
diff
changeset
|
260 |
_allocator->release(node); |
1374 | 261 |
} |
262 |
||
4481 | 263 |
void PtrQueue::handle_zero_index() { |
46443 | 264 |
assert(index() == 0, "precondition"); |
7920 | 265 |
|
4481 | 266 |
// This thread records the full buffer and allocates a new one (while |
267 |
// holding the lock if there is one). |
|
268 |
if (_buf != NULL) { |
|
7920 | 269 |
if (!should_enqueue_buffer()) { |
46443 | 270 |
assert(index() > 0, "the buffer can only be re-used if it's not full"); |
7920 | 271 |
return; |
272 |
} |
|
273 |
||
4481 | 274 |
if (_lock) { |
4640
b5edb9b319e4
6915005: G1: Hang in PtrQueueSet::completed_buffers_list_length with gcl001
johnc
parents:
4481
diff
changeset
|
275 |
assert(_lock->owned_by_self(), "Required."); |
b5edb9b319e4
6915005: G1: Hang in PtrQueueSet::completed_buffers_list_length with gcl001
johnc
parents:
4481
diff
changeset
|
276 |
|
46443 | 277 |
BufferNode* node = BufferNode::make_node_from_buffer(_buf, index()); |
4640
b5edb9b319e4
6915005: G1: Hang in PtrQueueSet::completed_buffers_list_length with gcl001
johnc
parents:
4481
diff
changeset
|
278 |
_buf = NULL; // clear shared _buf field |
b5edb9b319e4
6915005: G1: Hang in PtrQueueSet::completed_buffers_list_length with gcl001
johnc
parents:
4481
diff
changeset
|
279 |
|
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
280 |
qset()->enqueue_completed_buffer(node); |
46685
b218dfc2853a
8182703: Correct G1 barrier queue lock orderings
eosterlund
parents:
46630
diff
changeset
|
281 |
assert(_buf == NULL, "multiple enqueuers appear to be racing"); |
4481 | 282 |
} else { |
46443 | 283 |
BufferNode* node = BufferNode::make_node_from_buffer(_buf, index()); |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
284 |
if (qset()->process_or_enqueue_completed_buffer(node)) { |
4481 | 285 |
// Recycle the buffer. No allocation. |
37065 | 286 |
assert(_buf == BufferNode::make_buffer_from_node(node), "invariant"); |
46443 | 287 |
assert(capacity() == qset()->buffer_size(), "invariant"); |
288 |
reset(); |
|
4481 | 289 |
return; |
290 |
} |
|
291 |
} |
|
292 |
} |
|
46443 | 293 |
// Set capacity in case this is the first allocation. |
294 |
set_capacity(qset()->buffer_size()); |
|
295 |
// Allocate a new buffer. |
|
4481 | 296 |
_buf = qset()->allocate_buffer(); |
46443 | 297 |
reset(); |
4481 | 298 |
} |
1374 | 299 |
|
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
300 |
bool PtrQueueSet::process_or_enqueue_completed_buffer(BufferNode* node) { |
4481 | 301 |
if (Thread::current()->is_Java_thread()) { |
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
302 |
// If the number of buffers exceeds the limit, make this Java |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
303 |
// thread do the processing itself. We don't lock to access |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
304 |
// buffer count or padding; it is fine to be imprecise here. The |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
305 |
// add of padding could overflow, which is treated as unlimited. |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
306 |
size_t limit = _max_completed_buffers + _completed_buffers_padding; |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
307 |
if ((_n_completed_buffers > limit) && (limit >= _max_completed_buffers)) { |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
308 |
if (mut_process_buffer(node)) { |
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
309 |
// Successfully processed; return true to allow buffer reuse. |
4481 | 310 |
return true; |
311 |
} |
|
1374 | 312 |
} |
4481 | 313 |
} |
314 |
// The buffer will be enqueued. The caller will have to get a new one. |
|
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
315 |
enqueue_completed_buffer(node); |
4481 | 316 |
return false; |
317 |
} |
|
1374 | 318 |
|
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
319 |
void PtrQueueSet::enqueue_completed_buffer(BufferNode* cbn) { |
4481 | 320 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
36354 | 321 |
cbn->set_next(NULL); |
1374 | 322 |
if (_completed_buffers_tail == NULL) { |
323 |
assert(_completed_buffers_head == NULL, "Well-formedness"); |
|
324 |
_completed_buffers_head = cbn; |
|
325 |
_completed_buffers_tail = cbn; |
|
326 |
} else { |
|
4481 | 327 |
_completed_buffers_tail->set_next(cbn); |
1374 | 328 |
_completed_buffers_tail = cbn; |
329 |
} |
|
330 |
_n_completed_buffers++; |
|
331 |
||
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
332 |
if (!_process_completed_buffers && |
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
333 |
(_n_completed_buffers > _process_completed_buffers_threshold)) { |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
334 |
_process_completed_buffers = true; |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36354
diff
changeset
|
335 |
if (_notify_when_complete) { |
4481 | 336 |
_cbl_mon->notify(); |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36354
diff
changeset
|
337 |
} |
1374 | 338 |
} |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
339 |
assert_completed_buffers_list_len_correct_locked(); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
340 |
} |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
341 |
|
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
342 |
BufferNode* PtrQueueSet::get_completed_buffer(size_t stop_at) { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
343 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
344 |
|
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
345 |
if (_n_completed_buffers <= stop_at) { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
346 |
return NULL; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
347 |
} |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
348 |
|
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
349 |
assert(_n_completed_buffers > 0, "invariant"); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
350 |
assert(_completed_buffers_head != NULL, "invariant"); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
351 |
assert(_completed_buffers_tail != NULL, "invariant"); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
352 |
|
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
353 |
BufferNode* bn = _completed_buffers_head; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
354 |
_n_completed_buffers--; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
355 |
_completed_buffers_head = bn->next(); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
356 |
if (_completed_buffers_head == NULL) { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
357 |
assert(_n_completed_buffers == 0, "invariant"); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
358 |
_completed_buffers_tail = NULL; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
359 |
_process_completed_buffers = false; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
360 |
} |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
361 |
assert_completed_buffers_list_len_correct_locked(); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
362 |
bn->set_next(NULL); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
363 |
return bn; |
1374 | 364 |
} |
365 |
||
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
366 |
void PtrQueueSet::abandon_completed_buffers() { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
367 |
BufferNode* buffers_to_delete = NULL; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
368 |
{ |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
369 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
370 |
buffers_to_delete = _completed_buffers_head; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
371 |
_completed_buffers_head = NULL; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
372 |
_completed_buffers_tail = NULL; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
373 |
_n_completed_buffers = 0; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
374 |
_process_completed_buffers = false; |
1374 | 375 |
} |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
376 |
while (buffers_to_delete != NULL) { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
377 |
BufferNode* bn = buffers_to_delete; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
378 |
buffers_to_delete = bn->next(); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
379 |
bn->set_next(NULL); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
380 |
deallocate_buffer(bn); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
381 |
} |
1374 | 382 |
} |
383 |
||
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
384 |
#ifdef ASSERT |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
385 |
|
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
386 |
void PtrQueueSet::assert_completed_buffers_list_len_correct_locked() { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
387 |
assert_lock_strong(_cbl_mon); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
388 |
size_t n = 0; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
389 |
for (BufferNode* bn = _completed_buffers_head; bn != NULL; bn = bn->next()) { |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
390 |
++n; |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
391 |
} |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
392 |
assert(n == _n_completed_buffers, |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
393 |
"Completed buffer length is wrong: counted: " SIZE_FORMAT |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
394 |
", expected: " SIZE_FORMAT, n, _n_completed_buffers); |
1374 | 395 |
} |
396 |
||
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
397 |
#endif // ASSERT |
1374 | 398 |
|
4481 | 399 |
// Merge lists of buffers. Notify the processing threads. |
400 |
// The source queue is emptied as a result. The queues |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
401 |
// must share the monitor. |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
402 |
void PtrQueueSet::merge_bufferlists(PtrQueueSet *src) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
403 |
assert(_cbl_mon == src->_cbl_mon, "Should share the same lock"); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
404 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
405 |
if (_completed_buffers_tail == NULL) { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
406 |
assert(_completed_buffers_head == NULL, "Well-formedness"); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
407 |
_completed_buffers_head = src->_completed_buffers_head; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
408 |
_completed_buffers_tail = src->_completed_buffers_tail; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
409 |
} else { |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
410 |
assert(_completed_buffers_head != NULL, "Well formedness"); |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
411 |
if (src->_completed_buffers_head != NULL) { |
4481 | 412 |
_completed_buffers_tail->set_next(src->_completed_buffers_head); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
413 |
_completed_buffers_tail = src->_completed_buffers_tail; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
414 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
415 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
416 |
_n_completed_buffers += src->_n_completed_buffers; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
417 |
|
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
418 |
src->_n_completed_buffers = 0; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
419 |
src->_completed_buffers_head = NULL; |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
420 |
src->_completed_buffers_tail = NULL; |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
421 |
src->_process_completed_buffers = false; |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
422 |
|
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
423 |
assert(_completed_buffers_head == NULL && _completed_buffers_tail == NULL || |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
424 |
_completed_buffers_head != NULL && _completed_buffers_tail != NULL, |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
425 |
"Sanity"); |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
426 |
assert_completed_buffers_list_len_correct_locked(); |
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
427 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
428 |
|
4481 | 429 |
void PtrQueueSet::notify_if_necessary() { |
430 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
|
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
431 |
if (_n_completed_buffers > _process_completed_buffers_threshold) { |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
52726
diff
changeset
|
432 |
_process_completed_buffers = true; |
4481 | 433 |
if (_notify_when_complete) |
434 |
_cbl_mon->notify(); |
|
2142
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
435 |
} |
032f4652700c
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
1623
diff
changeset
|
436 |
} |