Mon, 02 Aug 2010 12:51:43 -0700
6814437: G1: remove the _new_refs array
Summary: The per-worker _new_refs array is used to hold references that point into the collection set. It is populated during RSet updating and subsequently processed. In the event of an evacuation failure it processed again to recreate the RSets of regions in the collection set. Remove the per-worker _new_refs array by processing the references directly. Use a DirtyCardQueue to hold the cards containing the references so that the RSets of regions in the collection set can be recreated when handling an evacuation failure.
Reviewed-by: iveresov, jmasa, tonyp
1 /*
2 * Copyright (c) 2001, 2007, 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 "incls/_precompiled.incl"
26 # include "incls/_satbQueue.cpp.incl"
28 void ObjPtrQueue::apply_closure(ObjectClosure* cl) {
29 if (_buf != NULL) {
30 apply_closure_to_buffer(cl, _buf, _index, _sz);
31 _index = _sz;
32 }
33 }
35 void ObjPtrQueue::apply_closure_to_buffer(ObjectClosure* cl,
36 void** buf, size_t index, size_t sz) {
37 if (cl == NULL) return;
38 for (size_t i = index; i < sz; i += oopSize) {
39 oop obj = (oop)buf[byte_index_to_index((int)i)];
40 // There can be NULL entries because of destructors.
41 if (obj != NULL) {
42 cl->do_object(obj);
43 }
44 }
45 }
47 #ifdef ASSERT
48 void ObjPtrQueue::verify_oops_in_buffer() {
49 if (_buf == NULL) return;
50 for (size_t i = _index; i < _sz; i += oopSize) {
51 oop obj = (oop)_buf[byte_index_to_index((int)i)];
52 assert(obj != NULL && obj->is_oop(true /* ignore mark word */),
53 "Not an oop");
54 }
55 }
56 #endif
58 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
59 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list
60 #endif // _MSC_VER
63 SATBMarkQueueSet::SATBMarkQueueSet() :
64 PtrQueueSet(),
65 _closure(NULL), _par_closures(NULL),
66 _shared_satb_queue(this, true /*perm*/)
67 {}
69 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock,
70 int process_completed_threshold,
71 Mutex* lock) {
72 PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1);
73 _shared_satb_queue.set_lock(lock);
74 if (ParallelGCThreads > 0) {
75 _par_closures = NEW_C_HEAP_ARRAY(ObjectClosure*, ParallelGCThreads);
76 }
77 }
80 void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) {
81 DEBUG_ONLY(t->satb_mark_queue().verify_oops_in_buffer();)
82 t->satb_mark_queue().handle_zero_index();
83 }
85 #ifdef ASSERT
86 void SATBMarkQueueSet::dump_active_values(JavaThread* first,
87 bool expected_active) {
88 gclog_or_tty->print_cr("SATB queue active values for Java Threads");
89 gclog_or_tty->print_cr(" SATB queue set: active is %s",
90 (is_active()) ? "TRUE" : "FALSE");
91 gclog_or_tty->print_cr(" expected_active is %s",
92 (expected_active) ? "TRUE" : "FALSE");
93 for (JavaThread* t = first; t; t = t->next()) {
94 bool active = t->satb_mark_queue().is_active();
95 gclog_or_tty->print_cr(" thread %s, active is %s",
96 t->name(), (active) ? "TRUE" : "FALSE");
97 }
98 }
99 #endif // ASSERT
101 void SATBMarkQueueSet::set_active_all_threads(bool b,
102 bool expected_active) {
103 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
104 JavaThread* first = Threads::first();
106 #ifdef ASSERT
107 if (_all_active != expected_active) {
108 dump_active_values(first, expected_active);
110 // I leave this here as a guarantee, instead of an assert, so
111 // that it will still be compiled in if we choose to uncomment
112 // the #ifdef ASSERT in a product build. The whole block is
113 // within an #ifdef ASSERT so the guarantee will not be compiled
114 // in a product build anyway.
115 guarantee(false,
116 "SATB queue set has an unexpected active value");
117 }
118 #endif // ASSERT
119 _all_active = b;
121 for (JavaThread* t = first; t; t = t->next()) {
122 #ifdef ASSERT
123 bool active = t->satb_mark_queue().is_active();
124 if (active != expected_active) {
125 dump_active_values(first, expected_active);
127 // I leave this here as a guarantee, instead of an assert, so
128 // that it will still be compiled in if we choose to uncomment
129 // the #ifdef ASSERT in a product build. The whole block is
130 // within an #ifdef ASSERT so the guarantee will not be compiled
131 // in a product build anyway.
132 guarantee(false,
133 "thread has an unexpected active value in its SATB queue");
134 }
135 #endif // ASSERT
136 t->satb_mark_queue().set_active(b);
137 }
138 }
140 void SATBMarkQueueSet::set_closure(ObjectClosure* closure) {
141 _closure = closure;
142 }
144 void SATBMarkQueueSet::set_par_closure(int i, ObjectClosure* par_closure) {
145 assert(ParallelGCThreads > 0 && _par_closures != NULL, "Precondition");
146 _par_closures[i] = par_closure;
147 }
149 void SATBMarkQueueSet::iterate_closure_all_threads() {
150 for(JavaThread* t = Threads::first(); t; t = t->next()) {
151 t->satb_mark_queue().apply_closure(_closure);
152 }
153 shared_satb_queue()->apply_closure(_closure);
154 }
156 void SATBMarkQueueSet::par_iterate_closure_all_threads(int worker) {
157 SharedHeap* sh = SharedHeap::heap();
158 int parity = sh->strong_roots_parity();
160 for(JavaThread* t = Threads::first(); t; t = t->next()) {
161 if (t->claim_oops_do(true, parity)) {
162 t->satb_mark_queue().apply_closure(_par_closures[worker]);
163 }
164 }
165 // We'll have worker 0 do this one.
166 if (worker == 0) {
167 shared_satb_queue()->apply_closure(_par_closures[0]);
168 }
169 }
171 bool SATBMarkQueueSet::apply_closure_to_completed_buffer_work(bool par,
172 int worker) {
173 BufferNode* nd = NULL;
174 {
175 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
176 if (_completed_buffers_head != NULL) {
177 nd = _completed_buffers_head;
178 _completed_buffers_head = nd->next();
179 if (_completed_buffers_head == NULL) _completed_buffers_tail = NULL;
180 _n_completed_buffers--;
181 if (_n_completed_buffers == 0) _process_completed = false;
182 }
183 }
184 ObjectClosure* cl = (par ? _par_closures[worker] : _closure);
185 if (nd != NULL) {
186 void **buf = BufferNode::make_buffer_from_node(nd);
187 ObjPtrQueue::apply_closure_to_buffer(cl, buf, 0, _sz);
188 deallocate_buffer(buf);
189 return true;
190 } else {
191 return false;
192 }
193 }
195 void SATBMarkQueueSet::abandon_partial_marking() {
196 BufferNode* buffers_to_delete = NULL;
197 {
198 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
199 while (_completed_buffers_head != NULL) {
200 BufferNode* nd = _completed_buffers_head;
201 _completed_buffers_head = nd->next();
202 nd->set_next(buffers_to_delete);
203 buffers_to_delete = nd;
204 }
205 _completed_buffers_tail = NULL;
206 _n_completed_buffers = 0;
207 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
208 }
209 while (buffers_to_delete != NULL) {
210 BufferNode* nd = buffers_to_delete;
211 buffers_to_delete = nd->next();
212 deallocate_buffer(BufferNode::make_buffer_from_node(nd));
213 }
214 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
215 // So we can safely manipulate these queues.
216 for (JavaThread* t = Threads::first(); t; t = t->next()) {
217 t->satb_mark_queue().reset();
218 }
219 shared_satb_queue()->reset();
220 }