1 /*
2 * Copyright (c) 1997, 2015, 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 */
24
25 #include "precompiled.hpp"
26 #include "compiler/compileBroker.hpp"
27 #include "gc_implementation/shared/gcTimer.hpp"
28 #include "gc_implementation/shared/gcTrace.hpp"
29 #include "gc_implementation/shared/markSweep.inline.hpp"
30 #include "gc_interface/collectedHeap.inline.hpp"
31 #include "oops/instanceKlass.inline.hpp"
32 #include "oops/instanceMirrorKlass.inline.hpp"
33 #include "oops/methodData.hpp"
34 #include "oops/objArrayKlass.inline.hpp"
35 #include "oops/oop.inline.hpp"
36
37 uint MarkSweep::_total_invocations = 0;
38
39 Stack<oop, mtGC> MarkSweep::_marking_stack;
40 Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack;
41
42 Stack<oop, mtGC> MarkSweep::_preserved_oop_stack;
43 Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack;
44 size_t MarkSweep::_preserved_count = 0;
45 size_t MarkSweep::_preserved_count_max = 0;
46 PreservedMark* MarkSweep::_preserved_marks = NULL;
47 ReferenceProcessor* MarkSweep::_ref_processor = NULL;
48 STWGCTimer* MarkSweep::_gc_timer = NULL;
49 SerialOldTracer* MarkSweep::_gc_tracer = NULL;
50
51 MarkSweep::FollowRootClosure MarkSweep::follow_root_closure;
52
53 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
54 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
55
56 MarkSweep::MarkAndPushClosure MarkSweep::mark_and_push_closure;
57 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure);
58 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure);
59
60 template <typename T>
61 void MarkSweep::MarkAndPushClosure::do_oop_nv(T* p) { mark_and_push(p); }
62 void MarkSweep::MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); }
63 void MarkSweep::MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
64
65 void MarkSweep::follow_class_loader(ClassLoaderData* cld) {
66 MarkSweep::follow_cld_closure.do_cld(cld);
67 }
68
69 void InstanceKlass::oop_ms_follow_contents(oop obj) {
70 assert(obj != NULL, "can't follow the content of NULL object");
71 MarkSweep::follow_klass(this);
72
73 oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::mark_and_push_closure);
74 }
75
76 void InstanceMirrorKlass::oop_ms_follow_contents(oop obj) {
77 InstanceKlass::oop_ms_follow_contents(obj);
78
79 // Follow the klass field in the mirror
80 Klass* klass = java_lang_Class::as_Klass(obj);
81 if (klass != NULL) {
82 // An anonymous class doesn't have its own class loader, so the call
83 // to follow_klass will mark and push its java mirror instead of the
84 // class loader. When handling the java mirror for an anonymous class
85 // we need to make sure its class loader data is claimed, this is done
86 // by calling follow_class_loader explicitly. For non-anonymous classes
87 // the call to follow_class_loader is made when the class loader itself
88 // is handled.
89 if (klass->oop_is_instance() && InstanceKlass::cast(klass)->is_anonymous()) {
90 MarkSweep::follow_class_loader(klass->class_loader_data());
91 } else {
92 MarkSweep::follow_klass(klass);
93 }
94 } else {
95 // If klass is NULL then this a mirror for a primitive type.
96 // We don't have to follow them, since they are handled as strong
97 // roots in Universe::oops_do.
98 assert(java_lang_Class::is_primitive(obj), "Sanity check");
99 }
100
101 oop_oop_iterate_statics<true>(obj, &MarkSweep::mark_and_push_closure);
102 }
103
104 void InstanceClassLoaderKlass::oop_ms_follow_contents(oop obj) {
105 InstanceKlass::oop_ms_follow_contents(obj);
106
107 ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
108
109 // We must NULL check here, since the class loader
110 // can be found before the loader data has been set up.
111 if(loader_data != NULL) {
112 MarkSweep::follow_class_loader(loader_data);
113 }
114 }
115
116 template <class T>
117 static void oop_ms_follow_contents_specialized(InstanceRefKlass* klass, oop obj) {
118 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
119 T heap_oop = oopDesc::load_heap_oop(referent_addr);
120 debug_only(
121 if(TraceReferenceGC && PrintGCDetails) {
122 gclog_or_tty->print_cr("InstanceRefKlass::oop_ms_follow_contents_specialized " PTR_FORMAT, p2i(obj));
123 }
124 )
125 if (!oopDesc::is_null(heap_oop)) {
126 oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
127 if (!referent->is_gc_marked() &&
128 MarkSweep::ref_processor()->discover_reference(obj, klass->reference_type())) {
129 // reference was discovered, referent will be traversed later
130 klass->InstanceKlass::oop_ms_follow_contents(obj);
131 debug_only(
132 if(TraceReferenceGC && PrintGCDetails) {
133 gclog_or_tty->print_cr(" Non NULL enqueued " PTR_FORMAT, p2i(obj));
134 }
135 )
136 return;
137 } else {
138 // treat referent as normal oop
139 debug_only(
140 if(TraceReferenceGC && PrintGCDetails) {
141 gclog_or_tty->print_cr(" Non NULL normal " PTR_FORMAT, p2i(obj));
142 }
143 )
144 MarkSweep::mark_and_push(referent_addr);
145 }
146 }
147 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
148 if (ReferenceProcessor::pending_list_uses_discovered_field()) {
149 // Treat discovered as normal oop, if ref is not "active",
150 // i.e. if next is non-NULL.
151 T next_oop = oopDesc::load_heap_oop(next_addr);
152 if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active"
153 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
154 debug_only(
155 if(TraceReferenceGC && PrintGCDetails) {
156 gclog_or_tty->print_cr(" Process discovered as normal "
157 PTR_FORMAT, p2i(discovered_addr));
158 }
159 )
160 MarkSweep::mark_and_push(discovered_addr);
161 }
162 } else {
163 #ifdef ASSERT
164 // In the case of older JDKs which do not use the discovered
165 // field for the pending list, an inactive ref (next != NULL)
166 // must always have a NULL discovered field.
167 oop next = oopDesc::load_decode_heap_oop(next_addr);
168 oop discovered = java_lang_ref_Reference::discovered(obj);
169 assert(oopDesc::is_null(next) || oopDesc::is_null(discovered),
170 err_msg("Found an inactive reference " PTR_FORMAT " with a non-NULL discovered field",
171 p2i(obj)));
172 #endif
173 }
174 // treat next as normal oop. next is a link in the reference queue.
175 debug_only(
176 if(TraceReferenceGC && PrintGCDetails) {
177 gclog_or_tty->print_cr(" Process next as normal " PTR_FORMAT, p2i(next_addr));
178 }
179 )
180 MarkSweep::mark_and_push(next_addr);
181 klass->InstanceKlass::oop_ms_follow_contents(obj);
182 }
183
184 void InstanceRefKlass::oop_ms_follow_contents(oop obj) {
185 if (UseCompressedOops) {
186 oop_ms_follow_contents_specialized<narrowOop>(this, obj);
187 } else {
188 oop_ms_follow_contents_specialized<oop>(this, obj);
189 }
190 }
191
192 template <class T>
193 static void oop_ms_follow_contents_specialized(oop obj, int index) {
194 objArrayOop a = objArrayOop(obj);
195 const size_t len = size_t(a->length());
196 const size_t beg_index = size_t(index);
197 assert(beg_index < len || len == 0, "index too large");
198
199 const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride);
200 const size_t end_index = beg_index + stride;
201 T* const base = (T*)a->base();
202 T* const beg = base + beg_index;
203 T* const end = base + end_index;
204
205 // Push the non-NULL elements of the next stride on the marking stack.
206 for (T* e = beg; e < end; e++) {
207 MarkSweep::mark_and_push<T>(e);
208 }
209
210 if (end_index < len) {
211 MarkSweep::push_objarray(a, end_index); // Push the continuation.
212 }
213 }
214
215 void ObjArrayKlass::oop_ms_follow_contents(oop obj) {
216 assert (obj->is_array(), "obj must be array");
217 MarkSweep::follow_klass(this);
218 if (UseCompressedOops) {
219 oop_ms_follow_contents_specialized<narrowOop>(obj, 0);
220 } else {
221 oop_ms_follow_contents_specialized<oop>(obj, 0);
222 }
223 }
224
225 void TypeArrayKlass::oop_ms_follow_contents(oop obj) {
226 assert(obj->is_typeArray(),"must be a type array");
227 // Performance tweak: We skip iterating over the klass pointer since we
228 // know that Universe::TypeArrayKlass never moves.
229 }
230
231 void MarkSweep::follow_array(objArrayOop array, int index) {
232 if (UseCompressedOops) {
233 oop_ms_follow_contents_specialized<narrowOop>(array, index);
234 } else {
235 oop_ms_follow_contents_specialized<oop>(array, index);
236 }
237 }
238
239 void MarkSweep::follow_stack() {
240 do {
241 while (!_marking_stack.is_empty()) {
242 oop obj = _marking_stack.pop();
243 assert (obj->is_gc_marked(), "p must be marked");
244 follow_object(obj);
245 }
246 // Process ObjArrays one at a time to avoid marking stack bloat.
247 if (!_objarray_stack.is_empty()) {
248 ObjArrayTask task = _objarray_stack.pop();
249 follow_array(objArrayOop(task.obj()), task.index());
250 }
251 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
252 }
253
254 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;
255
256 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }
257
258 void PreservedMark::adjust_pointer() {
259 MarkSweep::adjust_pointer(&_obj);
260 }
261
262 void PreservedMark::restore() {
263 _obj->set_mark(_mark);
264 }
265
266 // We preserve the mark which should be replaced at the end and the location
267 // that it will go. Note that the object that this markOop belongs to isn't
268 // currently at that address but it will be after phase4
269 void MarkSweep::preserve_mark(oop obj, markOop mark) {
270 // We try to store preserved marks in the to space of the new generation since
271 // this is storage which should be available. Most of the time this should be
272 // sufficient space for the marks we need to preserve but if it isn't we fall
273 // back to using Stacks to keep track of the overflow.
274 if (_preserved_count < _preserved_count_max) {
275 _preserved_marks[_preserved_count++].init(obj, mark);
276 } else {
277 _preserved_mark_stack.push(mark);
278 _preserved_oop_stack.push(obj);
279 }
280 }
281
282 MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure;
283
284 template <typename T>
285 void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p) { adjust_pointer(p); }
286 void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); }
287 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
288
289 void MarkSweep::adjust_marks() {
290 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
291 "inconsistent preserved oop stacks");
292
293 // adjust the oops we saved earlier
294 for (size_t i = 0; i < _preserved_count; i++) {
295 _preserved_marks[i].adjust_pointer();
296 }
297
298 // deal with the overflow stack
299 StackIterator<oop, mtGC> iter(_preserved_oop_stack);
300 while (!iter.is_empty()) {
301 oop* p = iter.next_addr();
302 adjust_pointer(p);
303 }
304 }
305
306 void MarkSweep::restore_marks() {
307 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
308 "inconsistent preserved oop stacks");
309 if (PrintGC && Verbose) {
310 gclog_or_tty->print_cr("Restoring " SIZE_FORMAT " marks",
311 _preserved_count + _preserved_oop_stack.size());
312 }
313
314 // restore the marks we saved earlier
315 for (size_t i = 0; i < _preserved_count; i++) {
316 _preserved_marks[i].restore();
317 }
318
319 // deal with the overflow
320 while (!_preserved_oop_stack.is_empty()) {
321 oop obj = _preserved_oop_stack.pop();
322 markOop mark = _preserved_mark_stack.pop();
323 obj->set_mark(mark);
324 }
325 }
326
327 MarkSweep::IsAliveClosure MarkSweep::is_alive;
328
329 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked(); }
330
331 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
332
333 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
334 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
335
336 void marksweep_init() {
337 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
338 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer();
339 }
340
341 int InstanceKlass::oop_ms_adjust_pointers(oop obj) {
342 int size = size_helper();
343 oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure);
344 return size;
345 }
346
347 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {
348 int size = oop_size(obj);
349 InstanceKlass::oop_ms_adjust_pointers(obj);
350
351 oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);
352 return size;
353 }
354
355 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {
356 return InstanceKlass::oop_ms_adjust_pointers(obj);
357 }
358
359 #ifdef ASSERT
360 template <class T> static void trace_reference_gc(const char *s, oop obj,
361 T* referent_addr,
362 T* next_addr,
363 T* discovered_addr) {
364 if(TraceReferenceGC && PrintGCDetails) {
365 gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));
366 gclog_or_tty->print_cr(" referent_addr/* " PTR_FORMAT " / "
367 PTR_FORMAT, p2i(referent_addr),
368 p2i(referent_addr ?
369 (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL));
370 gclog_or_tty->print_cr(" next_addr/* " PTR_FORMAT " / "
371 PTR_FORMAT, p2i(next_addr),
372 p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL));
373 gclog_or_tty->print_cr(" discovered_addr/* " PTR_FORMAT " / "
374 PTR_FORMAT, p2i(discovered_addr),
375 p2i(discovered_addr ?
376 (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL));
377 }
378 }
379 #endif
380
381 template <class T> void static adjust_object_specialized(oop obj) {
382 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
383 MarkSweep::adjust_pointer(referent_addr);
384 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
385 MarkSweep::adjust_pointer(next_addr);
386 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
387 MarkSweep::adjust_pointer(discovered_addr);
388 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj,
389 referent_addr, next_addr, discovered_addr);)
390 }
391
392 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) {
393 int size = size_helper();
394 InstanceKlass::oop_ms_adjust_pointers(obj);
395
396 if (UseCompressedOops) {
397 adjust_object_specialized<narrowOop>(obj);
398 } else {
399 adjust_object_specialized<oop>(obj);
400 }
401 return size;
402 }
403
404 int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) {
405 assert(obj->is_objArray(), "obj must be obj array");
406 objArrayOop a = objArrayOop(obj);
407 // Get size before changing pointers.
408 // Don't call size() or oop_size() since that is a virtual call.
409 int size = a->object_size();
410 oop_oop_iterate_elements<true>(a, &MarkSweep::adjust_pointer_closure);
411 return size;
412 }
413
414 int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) {
415 assert(obj->is_typeArray(), "must be a type array");
416 typeArrayOop t = typeArrayOop(obj);
417 // Performance tweak: We skip iterating over the klass pointer since we
418 // know that Universe::TypeArrayKlass never moves.
419 return t->object_size();
420 }