Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/satbQueue.cpp @ 20218:828056cf311f
8040792: G1: Memory usage calculation uses sizeof(this) instead of sizeof(classname)
Summary: A few locations in the code use sizeof(this) which returns the size of the pointer instead of sizeof(classname) which returns the size of the sum of its members. This change fixes these errors and adds a few tests.
Reviewed-by: mgerdin, brutisso
author | tschatzl |
---|---|
date | Mon, 21 Jul 2014 09:40:19 +0200 |
parents | 78bbf4d43a14 |
children | 52b4284cb496 2c6ef90f030a 42c091d63c72 |
rev | line source |
---|---|
342 | 1 /* |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17844
diff
changeset
|
2 * Copyright (c) 2001, 2014, 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" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
30 #include "oops/oop.inline.hpp" |
1972 | 31 #include "runtime/mutexLocker.hpp" |
32 #include "runtime/thread.hpp" | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
33 #include "runtime/vmThread.hpp" |
342 | 34 |
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17844
diff
changeset
|
35 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17844
diff
changeset
|
36 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
37 void ObjPtrQueue::flush() { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
38 // 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
|
39 // 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
|
40 // 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
|
41 filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
42 PtrQueue::flush(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
43 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
44 |
2149 | 45 // This method removes entries from an SATB buffer that will not be |
46 // useful to the concurrent marking threads. An entry is removed if it | |
47 // satisfies one of the following conditions: | |
48 // | |
49 // * it points to an object outside the G1 heap (G1's concurrent | |
50 // marking only visits objects inside the G1 heap), | |
51 // * it points to an object that has been allocated since marking | |
52 // started (according to SATB those objects do not need to be | |
53 // visited during marking), or | |
54 // * it points to an object that has already been marked (no need to | |
55 // process it again). | |
56 // | |
57 // 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
|
58 // 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
|
59 // 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
|
60 // 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
|
61 // references into the CSet will be removed during filtering. |
2149 | 62 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
63 void ObjPtrQueue::filter() { |
2149 | 64 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
65 void** buf = _buf; | |
66 size_t sz = _sz; | |
67 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
68 if (buf == NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
69 // nothing to do |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
70 return; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
71 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
72 |
2149 | 73 // Used for sanity checking at the end of the loop. |
74 debug_only(size_t entries = 0; size_t retained = 0;) | |
75 | |
76 size_t i = sz; | |
77 size_t new_index = sz; | |
78 | |
79 while (i > _index) { | |
80 assert(i > 0, "we should have at least one more entry to process"); | |
81 i -= oopSize; | |
82 debug_only(entries += 1;) | |
83 oop* p = (oop*) &buf[byte_index_to_index((int) i)]; | |
84 oop obj = *p; | |
85 // NULL the entry so that unused parts of the buffer contain NULLs | |
86 // at the end. If we are going to retain it we will copy it to its | |
87 // final place. If we have retained all entries we have visited so | |
88 // far, we'll just end up copying it to the same place. | |
89 *p = NULL; | |
90 | |
91 bool retain = g1h->is_obj_ill(obj); | |
92 if (retain) { | |
93 assert(new_index > 0, "we should not have already filled up the buffer"); | |
94 new_index -= oopSize; | |
95 assert(new_index >= i, | |
96 "new_index should never be below i, as we alwaysr compact 'up'"); | |
97 oop* new_p = (oop*) &buf[byte_index_to_index((int) new_index)]; | |
98 assert(new_p >= p, "the destination location should never be below " | |
99 "the source as we always compact 'up'"); | |
100 assert(*new_p == NULL, | |
101 "we should have already cleared the destination location"); | |
102 *new_p = obj; | |
103 debug_only(retained += 1;) | |
104 } | |
105 } | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
106 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
107 #ifdef ASSERT |
2149 | 108 size_t entries_calc = (sz - _index) / oopSize; |
109 assert(entries == entries_calc, "the number of entries we counted " | |
110 "should match the number of entries we calculated"); | |
111 size_t retained_calc = (sz - new_index) / oopSize; | |
112 assert(retained == retained_calc, "the number of retained entries we counted " | |
113 "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
|
114 #endif // ASSERT |
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 _index = new_index; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
117 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
118 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
119 // 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
|
120 // 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
|
121 // 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
|
122 // 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
|
123 // instead of replacing it. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
124 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
125 bool ObjPtrQueue::should_enqueue_buffer() { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
126 assert(_lock == NULL || _lock->owned_by_self(), |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
127 "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
|
128 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
129 // Even if G1SATBBufferEnqueueingThresholdPercent == 0 we have to |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
130 // 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
|
131 // 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
|
132 // enqueued buffers. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
133 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
134 // 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
|
135 // that is full. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
136 assert(_index == 0, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
137 assert(_buf != NULL, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
138 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
139 filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
140 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
141 size_t sz = _sz; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
142 size_t all_entries = sz / oopSize; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
143 size_t retained_entries = (sz - _index) / oopSize; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
144 size_t perc = retained_entries * 100 / all_entries; |
2149 | 145 bool should_enqueue = perc > (size_t) G1SATBBufferEnqueueingThresholdPercent; |
146 return should_enqueue; | |
147 } | |
148 | |
342 | 149 void ObjPtrQueue::apply_closure(ObjectClosure* cl) { |
150 if (_buf != NULL) { | |
151 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
|
152 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
153 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
154 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
155 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
|
156 if (_buf != NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
157 apply_closure_to_buffer(cl, _buf, _index, _sz); |
342 | 158 _index = _sz; |
159 } | |
160 } | |
161 | |
162 void ObjPtrQueue::apply_closure_to_buffer(ObjectClosure* cl, | |
163 void** buf, size_t index, size_t sz) { | |
164 if (cl == NULL) return; | |
165 for (size_t i = index; i < sz; i += oopSize) { | |
166 oop obj = (oop)buf[byte_index_to_index((int)i)]; | |
167 // There can be NULL entries because of destructors. | |
168 if (obj != NULL) { | |
169 cl->do_object(obj); | |
170 } | |
171 } | |
172 } | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
173 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
174 #ifndef PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
175 // Helpful for debugging |
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 void ObjPtrQueue::print(const char* name) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
178 print(name, _buf, _index, _sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
179 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
180 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
181 void ObjPtrQueue::print(const char* name, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
182 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
|
183 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
|
184 "index: "SIZE_FORMAT" sz: "SIZE_FORMAT, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
185 name, buf, index, sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
186 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
187 #endif // PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
188 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
189 #ifdef ASSERT |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
190 void ObjPtrQueue::verify_oops_in_buffer() { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
191 if (_buf == NULL) return; |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
192 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
|
193 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
|
194 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
|
195 "Not an oop"); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
196 } |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
197 } |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
198 #endif |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
199 |
342 | 200 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away |
201 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
202 #endif // _MSC_VER | |
203 | |
204 SATBMarkQueueSet::SATBMarkQueueSet() : | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
205 PtrQueueSet(), _closure(NULL), _par_closures(NULL), |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
206 _shared_satb_queue(this, true /*perm*/) { } |
342 | 207 |
208 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock, | |
1111 | 209 int process_completed_threshold, |
342 | 210 Mutex* lock) { |
1111 | 211 PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1); |
342 | 212 _shared_satb_queue.set_lock(lock); |
213 if (ParallelGCThreads > 0) { | |
6197 | 214 _par_closures = NEW_C_HEAP_ARRAY(ObjectClosure*, ParallelGCThreads, mtGC); |
342 | 215 } |
216 } | |
217 | |
218 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
|
219 DEBUG_ONLY(t->satb_mark_queue().verify_oops_in_buffer();) |
342 | 220 t->satb_mark_queue().handle_zero_index(); |
221 } | |
222 | |
1317
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
223 #ifdef ASSERT |
17747 | 224 void SATBMarkQueueSet::dump_active_states(bool expected_active) { |
225 gclog_or_tty->print_cr("Expected SATB active state: %s", | |
226 expected_active ? "ACTIVE" : "INACTIVE"); | |
227 gclog_or_tty->print_cr("Actual SATB active states:"); | |
228 gclog_or_tty->print_cr(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE"); | |
229 for (JavaThread* t = Threads::first(); t; t = t->next()) { | |
230 gclog_or_tty->print_cr(" Thread \"%s\" queue: %s", t->name(), | |
231 t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE"); | |
232 } | |
233 gclog_or_tty->print_cr(" Shared queue: %s", | |
234 shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE"); | |
235 } | |
236 | |
237 void SATBMarkQueueSet::verify_active_states(bool expected_active) { | |
238 // Verify queue set state | |
239 if (is_active() != expected_active) { | |
240 dump_active_states(expected_active); | |
241 guarantee(false, "SATB queue set has an unexpected active state"); | |
242 } | |
243 | |
244 // Verify thread queue states | |
245 for (JavaThread* t = Threads::first(); t; t = t->next()) { | |
246 if (t->satb_mark_queue().is_active() != expected_active) { | |
247 dump_active_states(expected_active); | |
248 guarantee(false, "Thread SATB queue has an unexpected active state"); | |
249 } | |
250 } | |
251 | |
252 // Verify shared queue state | |
253 if (shared_satb_queue()->is_active() != expected_active) { | |
254 dump_active_states(expected_active); | |
255 guarantee(false, "Shared SATB queue has an unexpected active state"); | |
1317
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
256 } |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
257 } |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
258 #endif // ASSERT |
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
259 |
17747 | 260 void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) { |
1317
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
261 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
|
262 #ifdef ASSERT |
17747 | 263 verify_active_states(expected_active); |
1317
d4197f8d516a
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
1111
diff
changeset
|
264 #endif // ASSERT |
17747 | 265 _all_active = active; |
266 for (JavaThread* t = Threads::first(); t; t = t->next()) { | |
267 t->satb_mark_queue().set_active(active); | |
342 | 268 } |
17747 | 269 shared_satb_queue()->set_active(active); |
342 | 270 } |
271 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
272 void SATBMarkQueueSet::filter_thread_buffers() { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
273 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
|
274 t->satb_mark_queue().filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
275 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
276 shared_satb_queue()->filter(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
277 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
278 |
342 | 279 void SATBMarkQueueSet::set_closure(ObjectClosure* closure) { |
280 _closure = closure; | |
281 } | |
282 | |
283 void SATBMarkQueueSet::set_par_closure(int i, ObjectClosure* par_closure) { | |
284 assert(ParallelGCThreads > 0 && _par_closures != NULL, "Precondition"); | |
285 _par_closures[i] = par_closure; | |
286 } | |
287 | |
288 void SATBMarkQueueSet::iterate_closure_all_threads() { | |
289 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
|
290 t->satb_mark_queue().apply_closure_and_empty(_closure); |
342 | 291 } |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
292 shared_satb_queue()->apply_closure_and_empty(_closure); |
342 | 293 } |
294 | |
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17747
diff
changeset
|
295 void SATBMarkQueueSet::par_iterate_closure_all_threads(uint worker) { |
342 | 296 SharedHeap* sh = SharedHeap::heap(); |
297 int parity = sh->strong_roots_parity(); | |
298 | |
299 for(JavaThread* t = Threads::first(); t; t = t->next()) { | |
300 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
|
301 t->satb_mark_queue().apply_closure_and_empty(_par_closures[worker]); |
342 | 302 } |
303 } | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
304 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
305 // 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
|
306 // otherwise the next call to Thread::possibly_parallel_oops_do inside |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
307 // a StrongRootsScope might skip the VMThread because it has a stale |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
308 // parity that matches the parity set by the StrongRootsScope |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
309 // |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
310 // Whichever worker succeeds in claiming the VMThread gets to do |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
311 // the shared queue. |
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 VMThread* vmt = VMThread::vm_thread(); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
2149
diff
changeset
|
314 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
|
315 shared_satb_queue()->apply_closure_and_empty(_par_closures[worker]); |
342 | 316 } |
317 } | |
318 | |
319 bool SATBMarkQueueSet::apply_closure_to_completed_buffer_work(bool par, | |
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17747
diff
changeset
|
320 uint worker) { |
1111 | 321 BufferNode* nd = NULL; |
342 | 322 { |
323 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); | |
324 if (_completed_buffers_head != NULL) { | |
325 nd = _completed_buffers_head; | |
1111 | 326 _completed_buffers_head = nd->next(); |
342 | 327 if (_completed_buffers_head == NULL) _completed_buffers_tail = NULL; |
328 _n_completed_buffers--; | |
329 if (_n_completed_buffers == 0) _process_completed = false; | |
330 } | |
331 } | |
332 ObjectClosure* cl = (par ? _par_closures[worker] : _closure); | |
333 if (nd != NULL) { | |
1111 | 334 void **buf = BufferNode::make_buffer_from_node(nd); |
335 ObjPtrQueue::apply_closure_to_buffer(cl, buf, 0, _sz); | |
336 deallocate_buffer(buf); | |
342 | 337 return true; |
338 } else { | |
339 return false; | |
340 } | |
341 } | |
342 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
343 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
|
344 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
|
345 assert(cl != NULL, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
346 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
347 BufferNode* nd = _completed_buffers_head; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
348 while (nd != NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
349 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
|
350 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
|
351 nd = nd->next(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
352 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
353 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
354 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
355 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
|
356 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
|
357 assert(cl != NULL, "pre-condition"); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
358 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
359 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
|
360 t->satb_mark_queue().apply_closure(cl); |
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 shared_satb_queue()->apply_closure(cl); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
363 } |
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 #ifndef PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
366 // Helpful for debugging |
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 #define SATB_PRINTER_BUFFER_SIZE 256 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
369 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
370 void SATBMarkQueueSet::print_all(const char* msg) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
371 char buffer[SATB_PRINTER_BUFFER_SIZE]; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
372 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
|
373 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
374 gclog_or_tty->cr(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
375 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
|
376 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
377 BufferNode* nd = _completed_buffers_head; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
378 int i = 0; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
379 while (nd != NULL) { |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
380 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
|
381 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
|
382 ObjPtrQueue::print(buffer, buf, 0, _sz); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
383 nd = nd->next(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
384 i += 1; |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
385 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
386 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
387 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
|
388 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
|
389 t->satb_mark_queue().print(buffer); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
390 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
391 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
392 shared_satb_queue()->print("Shared"); |
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 gclog_or_tty->cr(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
395 } |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
396 #endif // PRODUCT |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
397 |
342 | 398 void SATBMarkQueueSet::abandon_partial_marking() { |
1111 | 399 BufferNode* buffers_to_delete = NULL; |
342 | 400 { |
401 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); | |
402 while (_completed_buffers_head != NULL) { | |
1111 | 403 BufferNode* nd = _completed_buffers_head; |
404 _completed_buffers_head = nd->next(); | |
405 nd->set_next(buffers_to_delete); | |
342 | 406 buffers_to_delete = nd; |
407 } | |
408 _completed_buffers_tail = NULL; | |
409 _n_completed_buffers = 0; | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
410 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked()); |
342 | 411 } |
412 while (buffers_to_delete != NULL) { | |
1111 | 413 BufferNode* nd = buffers_to_delete; |
414 buffers_to_delete = nd->next(); | |
415 deallocate_buffer(BufferNode::make_buffer_from_node(nd)); | |
342 | 416 } |
417 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); | |
418 // So we can safely manipulate these queues. | |
419 for (JavaThread* t = Threads::first(); t; t = t->next()) { | |
420 t->satb_mark_queue().reset(); | |
421 } | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3979
diff
changeset
|
422 shared_satb_queue()->reset(); |
342 | 423 } |