author | tschatzl |
Wed, 12 Jul 2017 12:26:57 +0200 | |
changeset 46653 | d72083d17b19 |
parent 46443 | cdb638b5ec53 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
46305
bff6d23aa1e3
8175221: Cleanup DirtyCardQueueSet::concatenate_log
kbarrett
parents:
40655
diff
changeset
|
2 |
* Copyright (c) 2001, 2017, 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:
4481
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4481
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:
4481
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
30764 | 26 |
#include "gc/g1/dirtyCardQueue.hpp" |
27 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
|
46653 | 28 |
#include "gc/g1/g1RemSet.hpp" |
30764 | 29 |
#include "gc/g1/heapRegionRemSet.hpp" |
30 |
#include "gc/shared/workgroup.hpp" |
|
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
40012
diff
changeset
|
31 |
#include "runtime/atomic.hpp" |
7397 | 32 |
#include "runtime/mutexLocker.hpp" |
33 |
#include "runtime/safepoint.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
10565
diff
changeset
|
34 |
#include "runtime/thread.inline.hpp" |
1374 | 35 |
|
46653 | 36 |
// Closure used for updating remembered sets and recording references that |
37 |
// point into the collection set while the mutator is running. |
|
38 |
// Assumed to be only executed concurrently with the mutator. Yields via |
|
39 |
// SuspendibleThreadSet after every card. |
|
40 |
class G1RefineCardConcurrentlyClosure: public CardTableEntryClosure { |
|
41 |
public: |
|
42 |
bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
|
43 |
G1CollectedHeap::heap()->g1_rem_set()->refine_card_concurrently(card_ptr, worker_i); |
|
44 |
||
45 |
if (SuspendibleThreadSet::should_yield()) { |
|
46 |
// Caller will actually yield. |
|
47 |
return false; |
|
48 |
} |
|
49 |
// Otherwise, we finished successfully; return true. |
|
50 |
return true; |
|
51 |
} |
|
52 |
}; |
|
53 |
||
35465 | 54 |
// Represents a set of free small integer ids. |
55 |
class FreeIdSet : public CHeapObj<mtGC> { |
|
56 |
enum { |
|
57 |
end_of_list = UINT_MAX, |
|
58 |
claimed = UINT_MAX - 1 |
|
59 |
}; |
|
60 |
||
61 |
uint _size; |
|
62 |
Monitor* _mon; |
|
63 |
||
64 |
uint* _ids; |
|
65 |
uint _hd; |
|
66 |
uint _waiters; |
|
67 |
uint _claimed; |
|
68 |
||
69 |
public: |
|
70 |
FreeIdSet(uint size, Monitor* mon); |
|
71 |
~FreeIdSet(); |
|
72 |
||
73 |
// Returns an unclaimed parallel id (waiting for one to be released if |
|
74 |
// necessary). |
|
75 |
uint claim_par_id(); |
|
76 |
||
77 |
void release_par_id(uint id); |
|
78 |
}; |
|
79 |
||
80 |
FreeIdSet::FreeIdSet(uint size, Monitor* mon) : |
|
81 |
_size(size), _mon(mon), _hd(0), _waiters(0), _claimed(0) |
|
82 |
{ |
|
83 |
guarantee(size != 0, "must be"); |
|
84 |
_ids = NEW_C_HEAP_ARRAY(uint, size, mtGC); |
|
85 |
for (uint i = 0; i < size - 1; i++) { |
|
86 |
_ids[i] = i+1; |
|
87 |
} |
|
88 |
_ids[size-1] = end_of_list; // end of list. |
|
89 |
} |
|
90 |
||
91 |
FreeIdSet::~FreeIdSet() { |
|
92 |
FREE_C_HEAP_ARRAY(uint, _ids); |
|
93 |
} |
|
94 |
||
95 |
uint FreeIdSet::claim_par_id() { |
|
96 |
MutexLockerEx x(_mon, Mutex::_no_safepoint_check_flag); |
|
97 |
while (_hd == end_of_list) { |
|
98 |
_waiters++; |
|
99 |
_mon->wait(Mutex::_no_safepoint_check_flag); |
|
100 |
_waiters--; |
|
101 |
} |
|
102 |
uint res = _hd; |
|
103 |
_hd = _ids[res]; |
|
104 |
_ids[res] = claimed; // For debugging. |
|
105 |
_claimed++; |
|
106 |
return res; |
|
107 |
} |
|
108 |
||
109 |
void FreeIdSet::release_par_id(uint id) { |
|
110 |
MutexLockerEx x(_mon, Mutex::_no_safepoint_check_flag); |
|
111 |
assert(_ids[id] == claimed, "Precondition."); |
|
112 |
_ids[id] = _hd; |
|
113 |
_hd = id; |
|
114 |
_claimed--; |
|
115 |
if (_waiters > 0) { |
|
116 |
_mon->notify_all(); |
|
117 |
} |
|
118 |
} |
|
119 |
||
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
120 |
DirtyCardQueue::DirtyCardQueue(DirtyCardQueueSet* qset, bool permanent) : |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
121 |
// Dirty card queues are always active, so we create them with their |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
122 |
// active field set to true. |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
123 |
PtrQueue(qset, permanent, true /* active */) |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
124 |
{ } |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
125 |
|
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
126 |
DirtyCardQueue::~DirtyCardQueue() { |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
127 |
if (!is_permanent()) { |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
128 |
flush(); |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
129 |
} |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
130 |
} |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
131 |
|
4481 | 132 |
DirtyCardQueueSet::DirtyCardQueueSet(bool notify_when_complete) : |
133 |
PtrQueueSet(notify_when_complete), |
|
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
134 |
_shared_dirty_card_queue(this, true /* permanent */), |
1374 | 135 |
_free_ids(NULL), |
136 |
_processed_buffers_mut(0), _processed_buffers_rs_thread(0) |
|
137 |
{ |
|
138 |
_all_active = true; |
|
139 |
} |
|
140 |
||
2882
d508a8bac491
6841831: G1: assert(contains_reference(from),"We just added it!") fires
iveresov
parents:
2881
diff
changeset
|
141 |
// Determines how many mutator threads can process the buffers in parallel. |
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23543
diff
changeset
|
142 |
uint DirtyCardQueueSet::num_par_ids() { |
40012
f69cfe79fe98
8161993: G1 crashes if active_processor_count changes during startup
tschatzl
parents:
37197
diff
changeset
|
143 |
return (uint)os::initial_active_processor_count(); |
1374 | 144 |
} |
145 |
||
46653 | 146 |
void DirtyCardQueueSet::initialize(Monitor* cbl_mon, |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
147 |
Mutex* fl_lock, |
4481 | 148 |
int process_completed_threshold, |
1374 | 149 |
int max_completed_queue, |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
150 |
Mutex* lock, |
35465 | 151 |
DirtyCardQueueSet* fl_owner, |
152 |
bool init_free_ids) { |
|
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
153 |
PtrQueueSet::initialize(cbl_mon, |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
154 |
fl_lock, |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
155 |
process_completed_threshold, |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
156 |
max_completed_queue, |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
157 |
fl_owner); |
3583
805584e16d0f
6864886: G1: rename -XX parameters related to update buffers
tonyp
parents:
2882
diff
changeset
|
158 |
set_buffer_size(G1UpdateBufferSize); |
1374 | 159 |
_shared_dirty_card_queue.set_lock(lock); |
35465 | 160 |
if (init_free_ids) { |
161 |
_free_ids = new FreeIdSet(num_par_ids(), _cbl_mon); |
|
162 |
} |
|
1374 | 163 |
} |
164 |
||
165 |
void DirtyCardQueueSet::handle_zero_index_for_thread(JavaThread* t) { |
|
166 |
t->dirty_card_queue().handle_zero_index(); |
|
167 |
} |
|
168 |
||
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
169 |
bool DirtyCardQueueSet::apply_closure_to_buffer(CardTableEntryClosure* cl, |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
170 |
BufferNode* node, |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
171 |
bool consume, |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
172 |
uint worker_i) { |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
173 |
if (cl == NULL) return true; |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
174 |
bool result = true; |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
175 |
void** buf = BufferNode::make_buffer_from_node(node); |
46443 | 176 |
size_t i = node->index(); |
177 |
size_t limit = buffer_size(); |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
178 |
for ( ; i < limit; ++i) { |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
179 |
jbyte* card_ptr = static_cast<jbyte*>(buf[i]); |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
180 |
assert(card_ptr != NULL, "invariant"); |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
181 |
if (!cl->do_card_ptr(card_ptr, worker_i)) { |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
182 |
result = false; // Incomplete processing. |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
183 |
break; |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
184 |
} |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
185 |
} |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
186 |
if (consume) { |
46443 | 187 |
assert(i <= buffer_size(), "invariant"); |
188 |
node->set_index(i); |
|
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
189 |
} |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
190 |
return result; |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
191 |
} |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
192 |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
193 |
#ifndef ASSERT |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
194 |
#define assert_fully_consumed(node, buffer_size) |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
195 |
#else |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
196 |
#define assert_fully_consumed(node, buffer_size) \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
197 |
do { \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
198 |
size_t _afc_index = (node)->index(); \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
199 |
size_t _afc_size = (buffer_size); \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
200 |
assert(_afc_index == _afc_size, \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
201 |
"Buffer was not fully consumed as claimed: index: " \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
202 |
SIZE_FORMAT ", size: " SIZE_FORMAT, \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
203 |
_afc_index, _afc_size); \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
204 |
} while (0) |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
205 |
#endif // ASSERT |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
206 |
|
37065 | 207 |
bool DirtyCardQueueSet::mut_process_buffer(BufferNode* node) { |
35465 | 208 |
guarantee(_free_ids != NULL, "must be"); |
1374 | 209 |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
210 |
uint worker_i = _free_ids->claim_par_id(); // temporarily claim an id |
46653 | 211 |
G1RefineCardConcurrentlyClosure cl; |
212 |
bool result = apply_closure_to_buffer(&cl, node, true, worker_i); |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
213 |
_free_ids->release_par_id(worker_i); // release the id |
1374 | 214 |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
215 |
if (result) { |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
216 |
assert_fully_consumed(node, buffer_size()); |
35481
53825bdb41a0
8145038: Simplify mut_process_buffer worker id management
aharlap
parents:
35465
diff
changeset
|
217 |
Atomic::inc(&_processed_buffers_mut); |
1374 | 218 |
} |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
219 |
return result; |
1374 | 220 |
} |
221 |
||
4481 | 222 |
|
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
223 |
BufferNode* DirtyCardQueueSet::get_completed_buffer(size_t stop_at) { |
4481 | 224 |
BufferNode* nd = NULL; |
1374 | 225 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
226 |
||
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
227 |
if (_n_completed_buffers <= stop_at) { |
1374 | 228 |
_process_completed = false; |
229 |
return NULL; |
|
230 |
} |
|
231 |
||
232 |
if (_completed_buffers_head != NULL) { |
|
233 |
nd = _completed_buffers_head; |
|
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
234 |
assert(_n_completed_buffers > 0, "Invariant"); |
4481 | 235 |
_completed_buffers_head = nd->next(); |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
236 |
_n_completed_buffers--; |
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
237 |
if (_completed_buffers_head == NULL) { |
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
238 |
assert(_n_completed_buffers == 0, "Invariant"); |
1374 | 239 |
_completed_buffers_tail = NULL; |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
240 |
} |
1374 | 241 |
} |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
242 |
DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked()); |
1374 | 243 |
return nd; |
244 |
} |
|
245 |
||
46653 | 246 |
bool DirtyCardQueueSet::refine_completed_buffer_concurrently(uint worker_i, size_t stop_at) { |
247 |
G1RefineCardConcurrentlyClosure cl; |
|
248 |
return apply_closure_to_completed_buffer(&cl, worker_i, stop_at, false); |
|
249 |
} |
|
250 |
||
251 |
bool DirtyCardQueueSet::apply_closure_during_gc(CardTableEntryClosure* cl, uint worker_i) { |
|
252 |
assert_at_safepoint(false); |
|
253 |
return apply_closure_to_completed_buffer(cl, worker_i, 0, true); |
|
254 |
} |
|
255 |
||
6247 | 256 |
bool DirtyCardQueueSet::apply_closure_to_completed_buffer(CardTableEntryClosure* cl, |
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23543
diff
changeset
|
257 |
uint worker_i, |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36179
diff
changeset
|
258 |
size_t stop_at, |
6247 | 259 |
bool during_pause) { |
260 |
assert(!during_pause || stop_at == 0, "Should not leave any completed buffers during a pause"); |
|
261 |
BufferNode* nd = get_completed_buffer(stop_at); |
|
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
262 |
if (nd == NULL) { |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
263 |
return false; |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
264 |
} else { |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
265 |
if (apply_closure_to_buffer(cl, nd, true, worker_i)) { |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
266 |
assert_fully_consumed(nd, buffer_size()); |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
267 |
// Done with fully processed buffer. |
37065 | 268 |
deallocate_buffer(nd); |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
269 |
Atomic::inc(&_processed_buffers_rs_thread); |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
270 |
} else { |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
271 |
// Return partially processed buffer to the queue. |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
272 |
guarantee(!during_pause, "Should never stop early"); |
37065 | 273 |
enqueue_complete_buffer(nd); |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
274 |
} |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
275 |
return true; |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
276 |
} |
6247 | 277 |
} |
278 |
||
24104
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
279 |
void DirtyCardQueueSet::par_apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl) { |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
280 |
BufferNode* nd = _cur_par_buffer_node; |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
281 |
while (nd != NULL) { |
37065 | 282 |
BufferNode* next = nd->next(); |
283 |
void* actual = Atomic::cmpxchg_ptr(next, &_cur_par_buffer_node, nd); |
|
24104
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
284 |
if (actual == nd) { |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
285 |
bool b = apply_closure_to_buffer(cl, nd, false); |
24104
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
286 |
guarantee(b, "Should not stop early."); |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
287 |
nd = next; |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
288 |
} else { |
37065 | 289 |
nd = static_cast<BufferNode*>(actual); |
24104
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
290 |
} |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
291 |
} |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
292 |
} |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
293 |
|
6247 | 294 |
// Deallocates any completed log buffers |
295 |
void DirtyCardQueueSet::clear() { |
|
4481 | 296 |
BufferNode* buffers_to_delete = NULL; |
1374 | 297 |
{ |
298 |
MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); |
|
299 |
while (_completed_buffers_head != NULL) { |
|
4481 | 300 |
BufferNode* nd = _completed_buffers_head; |
301 |
_completed_buffers_head = nd->next(); |
|
302 |
nd->set_next(buffers_to_delete); |
|
1374 | 303 |
buffers_to_delete = nd; |
304 |
} |
|
305 |
_n_completed_buffers = 0; |
|
306 |
_completed_buffers_tail = NULL; |
|
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
307 |
DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked()); |
1374 | 308 |
} |
309 |
while (buffers_to_delete != NULL) { |
|
4481 | 310 |
BufferNode* nd = buffers_to_delete; |
311 |
buffers_to_delete = nd->next(); |
|
37065 | 312 |
deallocate_buffer(nd); |
1374 | 313 |
} |
6247 | 314 |
|
315 |
} |
|
316 |
||
317 |
void DirtyCardQueueSet::abandon_logs() { |
|
318 |
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
|
319 |
clear(); |
|
1374 | 320 |
// Since abandon is done only at safepoints, we can safely manipulate |
321 |
// these queues. |
|
322 |
for (JavaThread* t = Threads::first(); t; t = t->next()) { |
|
323 |
t->dirty_card_queue().reset(); |
|
324 |
} |
|
325 |
shared_dirty_card_queue()->reset(); |
|
326 |
} |
|
327 |
||
37065 | 328 |
void DirtyCardQueueSet::concatenate_log(DirtyCardQueue& dcq) { |
329 |
if (!dcq.is_empty()) { |
|
46305
bff6d23aa1e3
8175221: Cleanup DirtyCardQueueSet::concatenate_log
kbarrett
parents:
40655
diff
changeset
|
330 |
dcq.flush(); |
37065 | 331 |
} |
332 |
} |
|
1374 | 333 |
|
334 |
void DirtyCardQueueSet::concatenate_logs() { |
|
335 |
// Iterate over all the threads, if we find a partial log add it to |
|
336 |
// the global list of logs. Temporarily turn off the limit on the number |
|
337 |
// of outstanding buffers. |
|
338 |
int save_max_completed_queue = _max_completed_queue; |
|
339 |
_max_completed_queue = max_jint; |
|
340 |
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
|
341 |
for (JavaThread* t = Threads::first(); t; t = t->next()) { |
|
37065 | 342 |
concatenate_log(t->dirty_card_queue()); |
1374 | 343 |
} |
37065 | 344 |
concatenate_log(_shared_dirty_card_queue); |
1374 | 345 |
// Restore the completed buffer queue limit. |
346 |
_max_completed_queue = save_max_completed_queue; |
|
347 |
} |