207 // that it will go. Note that the object that this markOop belongs to isn't
208 // currently at that address but it will be after phase4
209 void MarkSweep::preserve_mark(oop obj, markOop mark) {
210 // We try to store preserved marks in the to space of the new generation since
211 // this is storage which should be available. Most of the time this should be
212 // sufficient space for the marks we need to preserve but if it isn't we fall
213 // back to using Stacks to keep track of the overflow.
214 if (_preserved_count < _preserved_count_max) {
215 _preserved_marks[_preserved_count++].init(obj, mark);
216 } else {
217 _preserved_mark_stack.push(mark);
218 _preserved_oop_stack.push(obj);
219 }
220 }
221
222 void MarkSweep::set_ref_processor(ReferenceProcessor* rp) {
223 _ref_processor = rp;
224 mark_and_push_closure.set_ref_processor(_ref_processor);
225 }
226
227 MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure;
228
229 template <typename T>
230 void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p) { adjust_pointer(p); }
231 void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); }
232 void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
233
234 void MarkSweep::adjust_marks() {
235 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
236 "inconsistent preserved oop stacks");
237
238 // adjust the oops we saved earlier
239 for (size_t i = 0; i < _preserved_count; i++) {
240 _preserved_marks[i].adjust_pointer();
241 }
242
243 // deal with the overflow stack
244 StackIterator<oop, mtGC> iter(_preserved_oop_stack);
245 while (!iter.is_empty()) {
246 oop* p = iter.next_addr();
247 adjust_pointer(p);
248 }
249 }
250
251 void MarkSweep::restore_marks() {
252 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
261 // deal with the overflow
262 while (!_preserved_oop_stack.is_empty()) {
263 oop obj = _preserved_oop_stack.pop();
264 markOop mark = _preserved_mark_stack.pop();
265 obj->set_mark(mark);
266 }
267 }
268
269 MarkSweep::IsAliveClosure MarkSweep::is_alive;
270
271 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); }
272
273 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
274
275 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
276 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
277
278 void marksweep_init() {
279 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
280 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer();
281 }
282
283 int InstanceKlass::oop_ms_adjust_pointers(oop obj) {
284 int size = size_helper();
285 oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure);
286 return size;
287 }
288
289 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {
290 int size = oop_size(obj);
291 InstanceKlass::oop_ms_adjust_pointers(obj);
292
293 oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);
294 return size;
295 }
296
297 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {
298 return InstanceKlass::oop_ms_adjust_pointers(obj);
299 }
300
301 #ifdef ASSERT
302 template <class T> static void trace_reference_gc(const char *s, oop obj,
303 T* referent_addr,
304 T* next_addr,
305 T* discovered_addr) {
306 log_develop_trace(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj));
307 log_develop_trace(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT,
308 p2i(referent_addr), p2i(referent_addr ? (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL));
309 log_develop_trace(gc, ref)(" next_addr/* " PTR_FORMAT " / " PTR_FORMAT,
310 p2i(next_addr), p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL));
311 log_develop_trace(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT,
312 p2i(discovered_addr), p2i(discovered_addr ? (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL));
313 }
314 #endif
315
316 template <class T> void static adjust_object_specialized(oop obj) {
317 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
318 MarkSweep::adjust_pointer(referent_addr);
319 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
320 MarkSweep::adjust_pointer(next_addr);
321 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
322 MarkSweep::adjust_pointer(discovered_addr);
323 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj,
324 referent_addr, next_addr, discovered_addr);)
325 }
326
327 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) {
328 int size = size_helper();
329 InstanceKlass::oop_ms_adjust_pointers(obj);
330
331 if (UseCompressedOops) {
332 adjust_object_specialized<narrowOop>(obj);
333 } else {
334 adjust_object_specialized<oop>(obj);
335 }
336 return size;
337 }
338
339 int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) {
340 assert(obj->is_objArray(), "obj must be obj array");
341 objArrayOop a = objArrayOop(obj);
342 // Get size before changing pointers.
343 // Don't call size() or oop_size() since that is a virtual call.
344 int size = a->object_size();
345 oop_oop_iterate_elements<true>(a, &MarkSweep::adjust_pointer_closure);
346 return size;
347 }
348
349 int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) {
350 assert(obj->is_typeArray(), "must be a type array");
351 typeArrayOop t = typeArrayOop(obj);
352 // Performance tweak: We skip iterating over the klass pointer since we
353 // know that Universe::TypeArrayKlass never moves.
354 return t->object_size();
355 }
356
357 // Generate MS specialized oop_oop_iterate functions.
358 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)
|
207 // that it will go. Note that the object that this markOop belongs to isn't
208 // currently at that address but it will be after phase4
209 void MarkSweep::preserve_mark(oop obj, markOop mark) {
210 // We try to store preserved marks in the to space of the new generation since
211 // this is storage which should be available. Most of the time this should be
212 // sufficient space for the marks we need to preserve but if it isn't we fall
213 // back to using Stacks to keep track of the overflow.
214 if (_preserved_count < _preserved_count_max) {
215 _preserved_marks[_preserved_count++].init(obj, mark);
216 } else {
217 _preserved_mark_stack.push(mark);
218 _preserved_oop_stack.push(obj);
219 }
220 }
221
222 void MarkSweep::set_ref_processor(ReferenceProcessor* rp) {
223 _ref_processor = rp;
224 mark_and_push_closure.set_ref_processor(_ref_processor);
225 }
226
227 AdjustPointerClosure MarkSweep::adjust_pointer_closure;
228
229 template <typename T>
230 void AdjustPointerClosure::do_oop_nv(T* p) { MarkSweep::adjust_pointer(p); }
231 void AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); }
232 void AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
233
234 void MarkSweep::adjust_marks() {
235 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
236 "inconsistent preserved oop stacks");
237
238 // adjust the oops we saved earlier
239 for (size_t i = 0; i < _preserved_count; i++) {
240 _preserved_marks[i].adjust_pointer();
241 }
242
243 // deal with the overflow stack
244 StackIterator<oop, mtGC> iter(_preserved_oop_stack);
245 while (!iter.is_empty()) {
246 oop* p = iter.next_addr();
247 adjust_pointer(p);
248 }
249 }
250
251 void MarkSweep::restore_marks() {
252 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
261 // deal with the overflow
262 while (!_preserved_oop_stack.is_empty()) {
263 oop obj = _preserved_oop_stack.pop();
264 markOop mark = _preserved_mark_stack.pop();
265 obj->set_mark(mark);
266 }
267 }
268
269 MarkSweep::IsAliveClosure MarkSweep::is_alive;
270
271 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); }
272
273 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
274
275 void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
276 void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
277
278 void marksweep_init() {
279 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
280 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer();
281 }
282
283 // Generate MS specialized oop_oop_iterate functions.
284 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)
|