author | kbarrett |
Tue, 21 May 2019 19:19:44 -0400 | |
changeset 54970 | 76d3d96a8bc2 |
parent 54255 | c81fbf340ceb |
child 55498 | e64383344f14 |
child 58678 | 9cf78a70fa4f |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
53482 | 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:
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/g1CollectedHeap.inline.hpp" |
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
27 |
#include "gc/g1/g1DirtyCardQueue.hpp" |
53482 | 28 |
#include "gc/g1/g1FreeIdSet.hpp" |
46653 | 29 |
#include "gc/g1/g1RemSet.hpp" |
49752
93d84f667d12
8201318: Introduce GCThreadLocalData to abstract GC-specific data belonging to a thread
pliden
parents:
49333
diff
changeset
|
30 |
#include "gc/g1/g1ThreadLocalData.hpp" |
30764 | 31 |
#include "gc/g1/heapRegionRemSet.hpp" |
52576
367ca5f32505
8213829: Remove circular dependency between g1CollectedHeap and g1ConcurrentMark
manc
parents:
49752
diff
changeset
|
32 |
#include "gc/shared/suspendibleThreadSet.hpp" |
30764 | 33 |
#include "gc/shared/workgroup.hpp" |
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
40012
diff
changeset
|
34 |
#include "runtime/atomic.hpp" |
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
35 |
#include "runtime/flags/flagSetting.hpp" |
7397 | 36 |
#include "runtime/mutexLocker.hpp" |
37 |
#include "runtime/safepoint.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
10565
diff
changeset
|
38 |
#include "runtime/thread.inline.hpp" |
48105
8d15b1369c7a
8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents:
47634
diff
changeset
|
39 |
#include "runtime/threadSMR.hpp" |
1374 | 40 |
|
46653 | 41 |
// Closure used for updating remembered sets and recording references that |
42 |
// point into the collection set while the mutator is running. |
|
43 |
// Assumed to be only executed concurrently with the mutator. Yields via |
|
44 |
// SuspendibleThreadSet after every card. |
|
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
45 |
class G1RefineCardConcurrentlyClosure: public G1CardTableEntryClosure { |
46653 | 46 |
public: |
54110 | 47 |
bool do_card_ptr(CardValue* card_ptr, uint worker_i) { |
53985
0da5c17f5e43
8219747: Remove g1_ prefix to g1_remset and g1_policy members in G1CollectedHeap
tschatzl
parents:
53747
diff
changeset
|
48 |
G1CollectedHeap::heap()->rem_set()->refine_card_concurrently(card_ptr, worker_i); |
46653 | 49 |
|
50 |
if (SuspendibleThreadSet::should_yield()) { |
|
51 |
// Caller will actually yield. |
|
52 |
return false; |
|
53 |
} |
|
54 |
// Otherwise, we finished successfully; return true. |
|
55 |
return true; |
|
56 |
} |
|
57 |
}; |
|
58 |
||
54255 | 59 |
G1DirtyCardQueue::G1DirtyCardQueue(G1DirtyCardQueueSet* qset) : |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
60 |
// 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
|
61 |
// active field set to true. |
54255 | 62 |
PtrQueue(qset, true /* active */) |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
63 |
{ } |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
64 |
|
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
65 |
G1DirtyCardQueue::~G1DirtyCardQueue() { |
54255 | 66 |
flush(); |
33761
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
67 |
} |
329db4b51480
6899049: G1: Clean up code in ptrQueue.[ch]pp and ptrQueue.inline.hpp
kbarrett
parents:
30764
diff
changeset
|
68 |
|
54970
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
69 |
void G1DirtyCardQueue::handle_completed_buffer() { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
70 |
assert(_buf != NULL, "precondition"); |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
71 |
BufferNode* node = BufferNode::make_node_from_buffer(_buf, index()); |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
72 |
G1DirtyCardQueueSet* dcqs = dirty_card_qset(); |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
73 |
if (dcqs->process_or_enqueue_completed_buffer(node)) { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
74 |
reset(); // Buffer fully processed, reset index. |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
75 |
} else { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
76 |
allocate_buffer(); // Buffer enqueued, get a new one. |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
77 |
} |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
78 |
} |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
79 |
|
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
80 |
G1DirtyCardQueueSet::G1DirtyCardQueueSet(bool notify_when_complete) : |
4481 | 81 |
PtrQueueSet(notify_when_complete), |
54970
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
82 |
_max_completed_buffers(MaxCompletedBuffersUnlimited), |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
83 |
_completed_buffers_padding(0), |
1374 | 84 |
_free_ids(NULL), |
53034
de99beff5c0e
8214946: G1: Initialize all class members on construction
lkorinth
parents:
52726
diff
changeset
|
85 |
_processed_buffers_mut(0), |
de99beff5c0e
8214946: G1: Initialize all class members on construction
lkorinth
parents:
52726
diff
changeset
|
86 |
_processed_buffers_rs_thread(0), |
de99beff5c0e
8214946: G1: Initialize all class members on construction
lkorinth
parents:
52726
diff
changeset
|
87 |
_cur_par_buffer_node(NULL) |
1374 | 88 |
{ |
89 |
_all_active = true; |
|
90 |
} |
|
91 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
92 |
G1DirtyCardQueueSet::~G1DirtyCardQueueSet() { |
53482 | 93 |
delete _free_ids; |
94 |
} |
|
95 |
||
2882
d508a8bac491
6841831: G1: assert(contains_reference(from),"We just added it!") fires
iveresov
parents:
2881
diff
changeset
|
96 |
// Determines how many mutator threads can process the buffers in parallel. |
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
97 |
uint G1DirtyCardQueueSet::num_par_ids() { |
40012
f69cfe79fe98
8161993: G1 crashes if active_processor_count changes during startup
tschatzl
parents:
37197
diff
changeset
|
98 |
return (uint)os::initial_active_processor_count(); |
1374 | 99 |
} |
100 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
101 |
void G1DirtyCardQueueSet::initialize(Monitor* cbl_mon, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
102 |
BufferNode::Allocator* allocator, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
103 |
bool init_free_ids) { |
52726
9cfa2e273b77
8214278: Cleanup process_completed_threshold and related state
kbarrett
parents:
52684
diff
changeset
|
104 |
PtrQueueSet::initialize(cbl_mon, allocator); |
35465 | 105 |
if (init_free_ids) { |
53482 | 106 |
_free_ids = new G1FreeIdSet(0, num_par_ids()); |
35465 | 107 |
} |
1374 | 108 |
} |
109 |
||
54006 | 110 |
void G1DirtyCardQueueSet::handle_zero_index_for_thread(Thread* t) { |
49752
93d84f667d12
8201318: Introduce GCThreadLocalData to abstract GC-specific data belonging to a thread
pliden
parents:
49333
diff
changeset
|
111 |
G1ThreadLocalData::dirty_card_queue(t).handle_zero_index(); |
1374 | 112 |
} |
113 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
114 |
bool G1DirtyCardQueueSet::apply_closure_to_buffer(G1CardTableEntryClosure* cl, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
115 |
BufferNode* node, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
116 |
bool consume, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
117 |
uint worker_i) { |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
118 |
if (cl == NULL) return true; |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
119 |
bool result = true; |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
120 |
void** buf = BufferNode::make_buffer_from_node(node); |
46443 | 121 |
size_t i = node->index(); |
122 |
size_t limit = buffer_size(); |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
123 |
for ( ; i < limit; ++i) { |
54110 | 124 |
CardTable::CardValue* card_ptr = static_cast<CardTable::CardValue*>(buf[i]); |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
125 |
assert(card_ptr != NULL, "invariant"); |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
126 |
if (!cl->do_card_ptr(card_ptr, worker_i)) { |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
127 |
result = false; // Incomplete processing. |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
128 |
break; |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
129 |
} |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
130 |
} |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
131 |
if (consume) { |
46443 | 132 |
assert(i <= buffer_size(), "invariant"); |
133 |
node->set_index(i); |
|
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
134 |
} |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
135 |
return result; |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
136 |
} |
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
137 |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
138 |
#ifndef ASSERT |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
139 |
#define assert_fully_consumed(node, buffer_size) |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
140 |
#else |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
141 |
#define assert_fully_consumed(node, buffer_size) \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
142 |
do { \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
143 |
size_t _afc_index = (node)->index(); \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
144 |
size_t _afc_size = (buffer_size); \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
145 |
assert(_afc_index == _afc_size, \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
146 |
"Buffer was not fully consumed as claimed: index: " \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
147 |
SIZE_FORMAT ", size: " SIZE_FORMAT, \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
148 |
_afc_index, _afc_size); \ |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
149 |
} while (0) |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
150 |
#endif // ASSERT |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
151 |
|
54970
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
152 |
bool G1DirtyCardQueueSet::process_or_enqueue_completed_buffer(BufferNode* node) { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
153 |
if (Thread::current()->is_Java_thread()) { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
154 |
// If the number of buffers exceeds the limit, make this Java |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
155 |
// thread do the processing itself. We don't lock to access |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
156 |
// buffer count or padding; it is fine to be imprecise here. The |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
157 |
// add of padding could overflow, which is treated as unlimited. |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
158 |
size_t max_buffers = max_completed_buffers(); |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
159 |
size_t limit = max_buffers + completed_buffers_padding(); |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
160 |
if ((completed_buffers_num() > limit) && (limit >= max_buffers)) { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
161 |
if (mut_process_buffer(node)) { |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
162 |
return true; |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
163 |
} |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
164 |
} |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
165 |
} |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
166 |
enqueue_completed_buffer(node); |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
167 |
return false; |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
168 |
} |
76d3d96a8bc2
8224167: Refactor PtrQueue completed buffer processing
kbarrett
parents:
54255
diff
changeset
|
169 |
|
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
170 |
bool G1DirtyCardQueueSet::mut_process_buffer(BufferNode* node) { |
35465 | 171 |
guarantee(_free_ids != NULL, "must be"); |
1374 | 172 |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
173 |
uint worker_i = _free_ids->claim_par_id(); // temporarily claim an id |
46653 | 174 |
G1RefineCardConcurrentlyClosure cl; |
175 |
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
|
176 |
_free_ids->release_par_id(worker_i); // release the id |
1374 | 177 |
|
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
178 |
if (result) { |
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
179 |
assert_fully_consumed(node, buffer_size()); |
35481
53825bdb41a0
8145038: Simplify mut_process_buffer worker id management
aharlap
parents:
35465
diff
changeset
|
180 |
Atomic::inc(&_processed_buffers_mut); |
1374 | 181 |
} |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
182 |
return result; |
1374 | 183 |
} |
184 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
185 |
bool G1DirtyCardQueueSet::refine_completed_buffer_concurrently(uint worker_i, size_t stop_at) { |
46653 | 186 |
G1RefineCardConcurrentlyClosure cl; |
187 |
return apply_closure_to_completed_buffer(&cl, worker_i, stop_at, false); |
|
188 |
} |
|
189 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
190 |
bool G1DirtyCardQueueSet::apply_closure_during_gc(G1CardTableEntryClosure* 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
|
191 |
assert_at_safepoint(); |
46653 | 192 |
return apply_closure_to_completed_buffer(cl, worker_i, 0, true); |
193 |
} |
|
194 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
195 |
bool G1DirtyCardQueueSet::apply_closure_to_completed_buffer(G1CardTableEntryClosure* cl, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
196 |
uint worker_i, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
197 |
size_t stop_at, |
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
198 |
bool during_pause) { |
6247 | 199 |
assert(!during_pause || stop_at == 0, "Should not leave any completed buffers during a pause"); |
200 |
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
|
201 |
if (nd == NULL) { |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
202 |
return false; |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
203 |
} else { |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
204 |
if (apply_closure_to_buffer(cl, nd, true, worker_i)) { |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
205 |
assert_fully_consumed(nd, buffer_size()); |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
206 |
// Done with fully processed buffer. |
37065 | 207 |
deallocate_buffer(nd); |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
208 |
Atomic::inc(&_processed_buffers_rs_thread); |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
209 |
} else { |
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
210 |
// Return partially processed buffer to the queue. |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
211 |
guarantee(!during_pause, "Should never stop early"); |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
53034
diff
changeset
|
212 |
enqueue_completed_buffer(nd); |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
213 |
} |
37197
282fa21230c3
8151670: Unexpected concurrent refinement deactivation and reactivation
kbarrett
parents:
37112
diff
changeset
|
214 |
return true; |
36179
03a0d7b8450f
8149793: DirtyCardQueueSet::apply_closure_to_completed_buffer_helper isn't helpful
kbarrett
parents:
35902
diff
changeset
|
215 |
} |
6247 | 216 |
} |
217 |
||
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
218 |
void G1DirtyCardQueueSet::par_apply_closure_to_all_completed_buffers(G1CardTableEntryClosure* cl) { |
24104
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
219 |
BufferNode* nd = _cur_par_buffer_node; |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
220 |
while (nd != NULL) { |
37065 | 221 |
BufferNode* next = nd->next(); |
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47216
diff
changeset
|
222 |
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
|
223 |
if (actual == nd) { |
37112
fe72d1d082ff
8151781: DirtyCardQueue::apply_closure is unused
kbarrett
parents:
37065
diff
changeset
|
224 |
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
|
225 |
guarantee(b, "Should not stop early."); |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
226 |
nd = next; |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
227 |
} else { |
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47216
diff
changeset
|
228 |
nd = actual; |
24104
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
229 |
} |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
230 |
} |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
231 |
} |
febf9363fb68
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
23855
diff
changeset
|
232 |
|
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
233 |
void G1DirtyCardQueueSet::abandon_logs() { |
6247 | 234 |
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
53034
diff
changeset
|
235 |
abandon_completed_buffers(); |
54006 | 236 |
|
1374 | 237 |
// Since abandon is done only at safepoints, we can safely manipulate |
238 |
// these queues. |
|
54006 | 239 |
struct AbandonThreadLogClosure : public ThreadClosure { |
240 |
virtual void do_thread(Thread* t) { |
|
241 |
G1ThreadLocalData::dirty_card_queue(t).reset(); |
|
242 |
} |
|
243 |
} closure; |
|
244 |
Threads::threads_do(&closure); |
|
245 |
||
54255 | 246 |
G1BarrierSet::shared_dirty_card_queue().reset(); |
37065 | 247 |
} |
1374 | 248 |
|
53747
13acc8e38a29
8218089: Rename DirtyCardQueue et al to follow usual G1 naming conventions
kbarrett
parents:
53482
diff
changeset
|
249 |
void G1DirtyCardQueueSet::concatenate_logs() { |
1374 | 250 |
// Iterate over all the threads, if we find a partial log add it to |
251 |
// the global list of logs. Temporarily turn off the limit on the number |
|
252 |
// of outstanding buffers. |
|
253 |
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
|
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
53034
diff
changeset
|
254 |
size_t old_limit = max_completed_buffers(); |
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
53034
diff
changeset
|
255 |
set_max_completed_buffers(MaxCompletedBuffersUnlimited); |
54006 | 256 |
|
54255 | 257 |
struct ConcatenateThreadLogClosure : public ThreadClosure { |
54006 | 258 |
virtual void do_thread(Thread* t) { |
54255 | 259 |
G1DirtyCardQueue& dcq = G1ThreadLocalData::dirty_card_queue(t); |
260 |
if (!dcq.is_empty()) { |
|
261 |
dcq.flush(); |
|
262 |
} |
|
54006 | 263 |
} |
54255 | 264 |
} closure; |
54006 | 265 |
Threads::threads_do(&closure); |
266 |
||
54255 | 267 |
G1BarrierSet::shared_dirty_card_queue().flush(); |
53102
35530ca3e0b2
8214201: Make PtrQueueSet completed buffer list private
kbarrett
parents:
53034
diff
changeset
|
268 |
set_max_completed_buffers(old_limit); |
1374 | 269 |
} |