hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
changeset 30150 d9c940aa42ef
parent 29798 451c73fdf690
child 30173 13cf7580b000
equal deleted inserted replaced
30149:c0f930abe5ed 30150:d9c940aa42ef
    32 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
    32 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
    33 #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
    33 #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
    34 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
    34 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
    35 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp"
    35 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp"
    36 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
    36 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
    37 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
    37 #include "gc_implementation/parallelScavenge/psParallelCompact.inline.hpp"
    38 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
    38 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
    39 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
    39 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
    40 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
    40 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
    41 #include "gc_implementation/shared/gcHeapSummary.hpp"
    41 #include "gc_implementation/shared/gcHeapSummary.hpp"
    42 #include "gc_implementation/shared/gcTimer.hpp"
    42 #include "gc_implementation/shared/gcTimer.hpp"
    46 #include "gc_implementation/shared/spaceDecorator.hpp"
    46 #include "gc_implementation/shared/spaceDecorator.hpp"
    47 #include "gc_interface/gcCause.hpp"
    47 #include "gc_interface/gcCause.hpp"
    48 #include "memory/gcLocker.inline.hpp"
    48 #include "memory/gcLocker.inline.hpp"
    49 #include "memory/referencePolicy.hpp"
    49 #include "memory/referencePolicy.hpp"
    50 #include "memory/referenceProcessor.hpp"
    50 #include "memory/referenceProcessor.hpp"
       
    51 #include "oops/instanceKlass.inline.hpp"
       
    52 #include "oops/instanceMirrorKlass.inline.hpp"
    51 #include "oops/methodData.hpp"
    53 #include "oops/methodData.hpp"
       
    54 #include "oops/objArrayKlass.inline.hpp"
    52 #include "oops/oop.inline.hpp"
    55 #include "oops/oop.inline.hpp"
    53 #include "runtime/atomic.inline.hpp"
    56 #include "runtime/atomic.inline.hpp"
    54 #include "runtime/fprofiler.hpp"
    57 #include "runtime/fprofiler.hpp"
    55 #include "runtime/safepoint.hpp"
    58 #include "runtime/safepoint.hpp"
    56 #include "runtime/vmThread.hpp"
    59 #include "runtime/vmThread.hpp"
   821 void PSParallelCompact::KeepAliveClosure::do_oop(narrowOop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
   824 void PSParallelCompact::KeepAliveClosure::do_oop(narrowOop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
   822 
   825 
   823 PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_pointer_closure;
   826 PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_pointer_closure;
   824 PSParallelCompact::AdjustKlassClosure PSParallelCompact::_adjust_klass_closure;
   827 PSParallelCompact::AdjustKlassClosure PSParallelCompact::_adjust_klass_closure;
   825 
   828 
   826 void PSParallelCompact::AdjustPointerClosure::do_oop(oop* p)       { adjust_pointer(p); }
       
   827 void PSParallelCompact::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p); }
       
   828 
       
   829 void PSParallelCompact::FollowStackClosure::do_void() { _compaction_manager->follow_marking_stacks(); }
   829 void PSParallelCompact::FollowStackClosure::do_void() { _compaction_manager->follow_marking_stacks(); }
   830 
       
   831 void PSParallelCompact::MarkAndPushClosure::do_oop(oop* p)       {
       
   832   mark_and_push(_compaction_manager, p);
       
   833 }
       
   834 void PSParallelCompact::MarkAndPushClosure::do_oop(narrowOop* p) { mark_and_push(_compaction_manager, p); }
       
   835 
   830 
   836 void PSParallelCompact::FollowKlassClosure::do_klass(Klass* klass) {
   831 void PSParallelCompact::FollowKlassClosure::do_klass(Klass* klass) {
   837   klass->oops_do(_mark_and_push_closure);
   832   klass->oops_do(_mark_and_push_closure);
   838 }
   833 }
   839 void PSParallelCompact::AdjustKlassClosure::do_klass(Klass* klass) {
   834 void PSParallelCompact::AdjustKlassClosure::do_klass(Klass* klass) {
  3336     Copy::aligned_conjoint_words(source(), destination(), words);
  3331     Copy::aligned_conjoint_words(source(), destination(), words);
  3337   }
  3332   }
  3338   update_state(words);
  3333   update_state(words);
  3339 }
  3334 }
  3340 
  3335 
       
  3336 void InstanceKlass::oop_pc_update_pointers(oop obj) {
       
  3337   oop_oop_iterate_oop_maps<true>(obj, PSParallelCompact::adjust_pointer_closure());
       
  3338 }
       
  3339 
       
  3340 void InstanceMirrorKlass::oop_pc_update_pointers(oop obj) {
       
  3341   InstanceKlass::oop_pc_update_pointers(obj);
       
  3342 
       
  3343   oop_oop_iterate_statics<true>(obj, PSParallelCompact::adjust_pointer_closure());
       
  3344 }
       
  3345 
       
  3346 void InstanceClassLoaderKlass::oop_pc_update_pointers(oop obj) {
       
  3347   InstanceKlass::oop_pc_update_pointers(obj);
       
  3348 }
       
  3349 
       
  3350 #ifdef ASSERT
       
  3351 template <class T> static void trace_reference_gc(const char *s, oop obj,
       
  3352                                                   T* referent_addr,
       
  3353                                                   T* next_addr,
       
  3354                                                   T* discovered_addr) {
       
  3355   if(TraceReferenceGC && PrintGCDetails) {
       
  3356     gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));
       
  3357     gclog_or_tty->print_cr("     referent_addr/* " PTR_FORMAT " / "
       
  3358                            PTR_FORMAT, p2i(referent_addr),
       
  3359                            referent_addr ? p2i(oopDesc::load_decode_heap_oop(referent_addr)) : NULL);
       
  3360     gclog_or_tty->print_cr("     next_addr/* " PTR_FORMAT " / "
       
  3361                            PTR_FORMAT, p2i(next_addr),
       
  3362                            next_addr ? p2i(oopDesc::load_decode_heap_oop(next_addr)) : NULL);
       
  3363     gclog_or_tty->print_cr("     discovered_addr/* " PTR_FORMAT " / "
       
  3364                            PTR_FORMAT, p2i(discovered_addr),
       
  3365                            discovered_addr ? p2i(oopDesc::load_decode_heap_oop(discovered_addr)) : NULL);
       
  3366   }
       
  3367 }
       
  3368 #endif
       
  3369 
       
  3370 template <class T>
       
  3371 static void oop_pc_update_pointers_specialized(oop obj) {
       
  3372   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
       
  3373   PSParallelCompact::adjust_pointer(referent_addr);
       
  3374   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
       
  3375   PSParallelCompact::adjust_pointer(next_addr);
       
  3376   T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
       
  3377   PSParallelCompact::adjust_pointer(discovered_addr);
       
  3378   debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
       
  3379                                 referent_addr, next_addr, discovered_addr);)
       
  3380 }
       
  3381 
       
  3382 void InstanceRefKlass::oop_pc_update_pointers(oop obj) {
       
  3383   InstanceKlass::oop_pc_update_pointers(obj);
       
  3384 
       
  3385   if (UseCompressedOops) {
       
  3386     oop_pc_update_pointers_specialized<narrowOop>(obj);
       
  3387   } else {
       
  3388     oop_pc_update_pointers_specialized<oop>(obj);
       
  3389   }
       
  3390 }
       
  3391 
       
  3392 void ObjArrayKlass::oop_pc_update_pointers(oop obj) {
       
  3393   assert(obj->is_objArray(), "obj must be obj array");
       
  3394   oop_oop_iterate_elements<true>(objArrayOop(obj), PSParallelCompact::adjust_pointer_closure());
       
  3395 }
       
  3396 
       
  3397 void TypeArrayKlass::oop_pc_update_pointers(oop obj) {
       
  3398   assert(obj->is_typeArray(),"must be a type array");
       
  3399 }
       
  3400 
  3341 ParMarkBitMapClosure::IterationStatus
  3401 ParMarkBitMapClosure::IterationStatus
  3342 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
  3402 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
  3343   assert(destination() != NULL, "sanity");
  3403   assert(destination() != NULL, "sanity");
  3344   assert(bitmap()->obj_size(addr) == words, "bad size");
  3404   assert(bitmap()->obj_size(addr) == words, "bad size");
  3345 
  3405