Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/satbQueue.cpp @ 6629:c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
Summary: Add the flags G1EvacuationFailureALot flag (and supporting flags) to force trigger evacuation failures. The support flags control how often to trigger an evacuation failure and during which types of evacuation pause. This functionality is analogous to that of PromotionFailureALot for the other collectors.
Reviewed-by: brutisso
author | johnc |
---|---|
date | Tue, 28 Aug 2012 15:20:08 -0700 |
parents | d2a62e0f25eb |
children | da91efe96a93 |
rev | line source |
---|---|
342 | 1 /* |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
342 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1317
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1317
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1317
diff
changeset
|
21 * questions. |
342 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
2149 | 26 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
1972 | 27 #include "gc_implementation/g1/satbQueue.hpp" |
28 #include "memory/allocation.inline.hpp" | |
29 #include "memory/sharedHeap.hpp" | |
30 #include "runtime/mutexLocker.hpp" | |
31 #include "runtime/thread.hpp" | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
32 #include "runtime/vmThread.hpp" |
342 | 33 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
34 void ObjPtrQueue::flush() { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
35 // The buffer might contain refs into the CSet. We have to filter it |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
36 // first before we flush it, otherwise we might end up with an |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
37 // enqueued buffer with refs into the CSet which breaks our invariants. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
38 filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
39 PtrQueue::flush(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
40 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
41 |
2149 | 42 // This method removes entries from an SATB buffer that will not be |
43 // useful to the concurrent marking threads. An entry is removed if it | |
44 // satisfies one of the following conditions: | |
45 // | |
46 // * it points to an object outside the G1 heap (G1's concurrent | |
47 // marking only visits objects inside the G1 heap), | |
48 // * it points to an object that has been allocated since marking | |
49 // started (according to SATB those objects do not need to be | |
50 // visited during marking), or | |
51 // * it points to an object that has already been marked (no need to | |
52 // process it again). | |
53 // | |
54 // The rest of the entries will be retained and are compacted towards | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
55 // the top of the buffer. Note that, because we do not allow old |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
56 // regions in the CSet during marking, all objects on the CSet regions |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
57 // are young (eden or survivors) and therefore implicitly live. So any |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
58 // references into the CSet will be removed during filtering. |
2149 | 59 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
60 void ObjPtrQueue::filter() { |
2149 | 61 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
62 void** buf = _buf; | |
63 size_t sz = _sz; | |
64 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
65 if (buf == NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
66 // nothing to do |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
67 return; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
68 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
69 |
2149 | 70 // Used for sanity checking at the end of the loop. |
71 debug_only(size_t entries = 0; size_t retained = 0;) | |
72 | |
73 size_t i = sz; | |
74 size_t new_index = sz; | |
75 | |
76 while (i > _index) { | |
77 assert(i > 0, "we should have at least one more entry to process"); | |
78 i -= oopSize; | |
79 debug_only(entries += 1;) | |
80 oop* p = (oop*) &buf[byte_index_to_index((int) i)]; | |
81 oop obj = *p; | |
82 // NULL the entry so that unused parts of the buffer contain NULLs | |
83 // at the end. If we are going to retain it we will copy it to its | |
84 // final place. If we have retained all entries we have visited so | |
85 // far, we'll just end up copying it to the same place. | |
86 *p = NULL; | |
87 | |
88 bool retain = g1h->is_obj_ill(obj); | |
89 if (retain) { | |
90 assert(new_index > 0, "we should not have already filled up the buffer"); | |
91 new_index -= oopSize; | |
92 assert(new_index >= i, | |
93 "new_index should never be below i, as we alwaysr compact 'up'"); | |
94 oop* new_p = (oop*) &buf[byte_index_to_index((int) new_index)]; | |
95 assert(new_p >= p, "the destination location should never be below " | |
96 "the source as we always compact 'up'"); | |
97 assert(*new_p == NULL, | |
98 "we should have already cleared the destination location"); | |
99 *new_p = obj; | |
100 debug_only(retained += 1;) | |
101 } | |
102 } | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
103 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
104 #ifdef ASSERT |
2149 | 105 size_t entries_calc = (sz - _index) / oopSize; |
106 assert(entries == entries_calc, "the number of entries we counted " | |
107 "should match the number of entries we calculated"); | |
108 size_t retained_calc = (sz - new_index) / oopSize; | |
109 assert(retained == retained_calc, "the number of retained entries we counted " | |
110 "should match the number of retained entries we calculated"); | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
111 #endif // ASSERT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
112 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
113 _index = new_index; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
114 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
115 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
116 // This method will first apply the above filtering to the buffer. If |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
117 // post-filtering a large enough chunk of the buffer has been cleared |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
118 // we can re-use the buffer (instead of enqueueing it) and we can just |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
119 // allow the mutator to carry on executing using the same buffer |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
120 // instead of replacing it. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
121 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
122 bool ObjPtrQueue::should_enqueue_buffer() { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
123 assert(_lock == NULL || _lock->owned_by_self(), |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
124 "we should have taken the lock before calling this"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
125 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
126 // Even if G1SATBBufferEnqueueingThresholdPercent == 0 we have to |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
127 // filter the buffer given that this will remove any references into |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
128 // the CSet as we currently assume that no such refs will appear in |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
129 // enqueued buffers. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
130 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
131 // This method should only be called if there is a non-NULL buffer |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
132 // that is full. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
133 assert(_index == 0, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
134 assert(_buf != NULL, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
135 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
136 filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
137 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
138 size_t sz = _sz; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
139 size_t all_entries = sz / oopSize; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
140 size_t retained_entries = (sz - _index) / oopSize; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
141 size_t perc = retained_entries * 100 / all_entries; |
2149 | 142 bool should_enqueue = perc > (size_t) G1SATBBufferEnqueueingThresholdPercent; |
143 return should_enqueue; | |
144 } | |
145 | |
342 | 146 void ObjPtrQueue::apply_closure(ObjectClosure* cl) { |
147 if (_buf != NULL) { | |
148 apply_closure_to_buffer(cl, _buf, _index, _sz); | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
149 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
150 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
151 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
152 void ObjPtrQueue::apply_closure_and_empty(ObjectClosure* cl) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
153 if (_buf != NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
154 apply_closure_to_buffer(cl, _buf, _index, _sz); |
342 | 155 _index = _sz; |
156 } | |
157 } | |
158 | |
159 void ObjPtrQueue::apply_closure_to_buffer(ObjectClosure* cl, | |
160 void** buf, size_t index, size_t sz) { | |
161 if (cl == NULL) return; | |
162 for (size_t i = index; i < sz; i += oopSize) { | |
163 oop obj = (oop)buf[byte_index_to_index((int)i)]; | |
164 // There can be NULL entries because of destructors. | |
165 if (obj != NULL) { | |
166 cl->do_object(obj); | |
167 } | |
168 } | |
169 } | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
170 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
171 #ifndef PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
172 // Helpful for debugging |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
173 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
174 void ObjPtrQueue::print(const char* name) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
175 print(name, _buf, _index, _sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
176 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
177 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
178 void ObjPtrQueue::print(const char* name, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
179 void** buf, size_t index, size_t sz) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
180 gclog_or_tty->print_cr(" SATB BUFFER [%s] buf: "PTR_FORMAT" " |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
181 "index: "SIZE_FORMAT" sz: "SIZE_FORMAT, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
182 name, buf, index, sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
183 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
184 #endif // PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
185 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
186 #ifdef ASSERT |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
187 void ObjPtrQueue::verify_oops_in_buffer() { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
188 if (_buf == NULL) return; |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
189 for (size_t i = _index; i < _sz; i += oopSize) { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
190 oop obj = (oop)_buf[byte_index_to_index((int)i)]; |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
191 assert(obj != NULL && obj->is_oop(true /* ignore mark word */), |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
192 "Not an oop"); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
193 } |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
194 } |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
195 #endif |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
196 |
342 | 197 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away |
198 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
199 #endif // _MSC_VER | |
200 | |
201 SATBMarkQueueSet::SATBMarkQueueSet() : | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
202 PtrQueueSet(), _closure(NULL), _par_closures(NULL), |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
203 _shared_satb_queue(this, true /*perm*/) { } |
342 | 204 |
205 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock, | |
1111 | 206 int process_completed_threshold, |
342 | 207 Mutex* lock) { |
1111 | 208 PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1); |
342 | 209 _shared_satb_queue.set_lock(lock); |
210 if (ParallelGCThreads > 0) { | |
6197 | 211 _par_closures = NEW_C_HEAP_ARRAY(ObjectClosure*, ParallelGCThreads, mtGC); |
342 | 212 } |
213 } | |
214 | |
215 void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) { | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
216 DEBUG_ONLY(t->satb_mark_queue().verify_oops_in_buffer();) |
342 | 217 t->satb_mark_queue().handle_zero_index(); |
218 } | |
219 | |
1317
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
220 #ifdef ASSERT |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
221 void SATBMarkQueueSet::dump_active_values(JavaThread* first, |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
222 bool expected_active) { |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
223 gclog_or_tty->print_cr("SATB queue active values for Java Threads"); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
224 gclog_or_tty->print_cr(" SATB queue set: active is %s", |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
225 (is_active()) ? "TRUE" : "FALSE"); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
226 gclog_or_tty->print_cr(" expected_active is %s", |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
227 (expected_active) ? "TRUE" : "FALSE"); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
228 for (JavaThread* t = first; t; t = t->next()) { |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
229 bool active = t->satb_mark_queue().is_active(); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
230 gclog_or_tty->print_cr(" thread %s, active is %s", |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
231 t->name(), (active) ? "TRUE" : "FALSE"); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
232 } |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
233 } |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
234 #endif // ASSERT |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
235 |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
236 void SATBMarkQueueSet::set_active_all_threads(bool b, |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
237 bool expected_active) { |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
238 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
239 JavaThread* first = Threads::first(); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
240 |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
241 #ifdef ASSERT |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
242 if (_all_active != expected_active) { |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
243 dump_active_values(first, expected_active); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
244 |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
245 // I leave this here as a guarantee, instead of an assert, so |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
246 // that it will still be compiled in if we choose to uncomment |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
247 // the #ifdef ASSERT in a product build. The whole block is |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
248 // within an #ifdef ASSERT so the guarantee will not be compiled |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
249 // in a product build anyway. |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
250 guarantee(false, |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
251 "SATB queue set has an unexpected active value"); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
252 } |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
253 #endif // ASSERT |
342 | 254 _all_active = b; |
1317
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
255 |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
256 for (JavaThread* t = first; t; t = t->next()) { |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
257 #ifdef ASSERT |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
258 bool active = t->satb_mark_queue().is_active(); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
259 if (active != expected_active) { |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
260 dump_active_values(first, expected_active); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
261 |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
262 // I leave this here as a guarantee, instead of an assert, so |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
263 // that it will still be compiled in if we choose to uncomment |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
264 // the #ifdef ASSERT in a product build. The whole block is |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
265 // within an #ifdef ASSERT so the guarantee will not be compiled |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
266 // in a product build anyway. |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
267 guarantee(false, |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
268 "thread has an unexpected active value in its SATB queue"); |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
269 } |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
270 #endif // ASSERT |
342 | 271 t->satb_mark_queue().set_active(b); |
272 } | |
273 } | |
274 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
275 void SATBMarkQueueSet::filter_thread_buffers() { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
276 for(JavaThread* t = Threads::first(); t; t = t->next()) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
277 t->satb_mark_queue().filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
278 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
279 shared_satb_queue()->filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
280 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
281 |
342 | 282 void SATBMarkQueueSet::set_closure(ObjectClosure* closure) { |
283 _closure = closure; | |
284 } | |
285 | |
286 void SATBMarkQueueSet::set_par_closure(int i, ObjectClosure* par_closure) { | |
287 assert(ParallelGCThreads > 0 && _par_closures != NULL, "Precondition"); | |
288 _par_closures[i] = par_closure; | |
289 } | |
290 | |
291 void SATBMarkQueueSet::iterate_closure_all_threads() { | |
292 for(JavaThread* t = Threads::first(); t; t = t->next()) { | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
293 t->satb_mark_queue().apply_closure_and_empty(_closure); |
342 | 294 } |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
295 shared_satb_queue()->apply_closure_and_empty(_closure); |
342 | 296 } |
297 | |
298 void SATBMarkQueueSet::par_iterate_closure_all_threads(int worker) { | |
299 SharedHeap* sh = SharedHeap::heap(); | |
300 int parity = sh->strong_roots_parity(); | |
301 | |
302 for(JavaThread* t = Threads::first(); t; t = t->next()) { | |
303 if (t->claim_oops_do(true, parity)) { | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
304 t->satb_mark_queue().apply_closure_and_empty(_par_closures[worker]); |
342 | 305 } |
306 } | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
307 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
308 // We also need to claim the VMThread so that its parity is updated |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
309 // otherwise the next call to Thread::possibly_parallel_oops_do inside |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
310 // a StrongRootsScope might skip the VMThread because it has a stale |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
311 // parity that matches the parity set by the StrongRootsScope |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
312 // |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
313 // Whichever worker succeeds in claiming the VMThread gets to do |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
314 // the shared queue. |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
315 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
316 VMThread* vmt = VMThread::vm_thread(); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
317 if (vmt->claim_oops_do(true, parity)) { |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
318 shared_satb_queue()->apply_closure_and_empty(_par_closures[worker]); |
342 | 319 } |
320 } | |
321 | |
322 bool SATBMarkQueueSet::apply_closure_to_completed_buffer_work(bool par, | |
323 int worker) { | |
1111 | 324 BufferNode* nd = NULL; |
342 | 325 { |
326 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); | |
327 if (_completed_buffers_head != NULL) { | |
328 nd = _completed_buffers_head; | |
1111 | 329 _completed_buffers_head = nd->next(); |
342 | 330 if (_completed_buffers_head == NULL) _completed_buffers_tail = NULL; |
331 _n_completed_buffers--; | |
332 if (_n_completed_buffers == 0) _process_completed = false; | |
333 } | |
334 } | |
335 ObjectClosure* cl = (par ? _par_closures[worker] : _closure); | |
336 if (nd != NULL) { | |
1111 | 337 void **buf = BufferNode::make_buffer_from_node(nd); |
338 ObjPtrQueue::apply_closure_to_buffer(cl, buf, 0, _sz); | |
339 deallocate_buffer(buf); | |
342 | 340 return true; |
341 } else { | |
342 return false; | |
343 } | |
344 } | |
345 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
346 void SATBMarkQueueSet::iterate_completed_buffers_read_only(ObjectClosure* cl) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
347 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
348 assert(cl != NULL, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
349 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
350 BufferNode* nd = _completed_buffers_head; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
351 while (nd != NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
352 void** buf = BufferNode::make_buffer_from_node(nd); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
353 ObjPtrQueue::apply_closure_to_buffer(cl, buf, 0, _sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
354 nd = nd->next(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
355 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
356 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
357 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
358 void SATBMarkQueueSet::iterate_thread_buffers_read_only(ObjectClosure* cl) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
359 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
360 assert(cl != NULL, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
361 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
362 for (JavaThread* t = Threads::first(); t; t = t->next()) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
363 t->satb_mark_queue().apply_closure(cl); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
364 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
365 shared_satb_queue()->apply_closure(cl); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
366 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
367 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
368 #ifndef PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
369 // Helpful for debugging |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
370 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
371 #define SATB_PRINTER_BUFFER_SIZE 256 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
372 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
373 void SATBMarkQueueSet::print_all(const char* msg) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
374 char buffer[SATB_PRINTER_BUFFER_SIZE]; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
375 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
376 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
377 gclog_or_tty->cr(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
378 gclog_or_tty->print_cr("SATB BUFFERS [%s]", msg); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
379 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
380 BufferNode* nd = _completed_buffers_head; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
381 int i = 0; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
382 while (nd != NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
383 void** buf = BufferNode::make_buffer_from_node(nd); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
384 jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Enqueued: %d", i); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
385 ObjPtrQueue::print(buffer, buf, 0, _sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
386 nd = nd->next(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
387 i += 1; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
388 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
389 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
390 for (JavaThread* t = Threads::first(); t; t = t->next()) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
391 jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name()); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
392 t->satb_mark_queue().print(buffer); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
393 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
394 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
395 shared_satb_queue()->print("Shared"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
396 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
397 gclog_or_tty->cr(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
398 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
399 #endif // PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
400 |
342 | 401 void SATBMarkQueueSet::abandon_partial_marking() { |
1111 | 402 BufferNode* buffers_to_delete = NULL; |
342 | 403 { |
404 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); | |
405 while (_completed_buffers_head != NULL) { | |
1111 | 406 BufferNode* nd = _completed_buffers_head; |
407 _completed_buffers_head = nd->next(); | |
408 nd->set_next(buffers_to_delete); | |
342 | 409 buffers_to_delete = nd; |
410 } | |
411 _completed_buffers_tail = NULL; | |
412 _n_completed_buffers = 0; | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
413 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked()); |
342 | 414 } |
415 while (buffers_to_delete != NULL) { | |
1111 | 416 BufferNode* nd = buffers_to_delete; |
417 buffers_to_delete = nd->next(); | |
418 deallocate_buffer(BufferNode::make_buffer_from_node(nd)); | |
342 | 419 } |
420 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); | |
421 // So we can safely manipulate these queues. | |
422 for (JavaThread* t = Threads::first(); t; t = t->next()) { | |
423 t->satb_mark_queue().reset(); | |
424 } | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
425 shared_satb_queue()->reset(); |
342 | 426 } |