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