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