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