src/hotspot/share/gc/parallel/psCompactionManager.inline.hpp

8211446: Replace oop_pc_follow_contents with oop_iterate and closure

*** 23,32 ****
--- 23,33 ----
   */
  
  #ifndef SHARE_VM_GC_PARALLEL_PSCOMPACTIONMANAGER_INLINE_HPP
  #define SHARE_VM_GC_PARALLEL_PSCOMPACTIONMANAGER_INLINE_HPP
  
+ #include "classfile/javaClasses.inline.hpp"
  #include "gc/parallel/parMarkBitMap.hpp"
  #include "gc/parallel/psCompactionManager.hpp"
  #include "gc/parallel/psParallelCompact.inline.hpp"
  #include "gc/shared/taskqueue.inline.hpp"
  #include "oops/access.inline.hpp"
***************
*** 82,121 ****
        push(obj);
      }
    }
  }
  
- template <typename T>
- inline void ParCompactionManager::MarkAndPushClosure::do_oop_work(T* p) {
-   _compaction_manager->mark_and_push(p);
- }
- 
- inline void ParCompactionManager::MarkAndPushClosure::do_oop(oop* p)       { do_oop_work(p); }
- inline void ParCompactionManager::MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_work(p); }
- 
  inline void ParCompactionManager::follow_klass(Klass* klass) {
    oop holder = klass->klass_holder();
    mark_and_push(&holder);
  }
  
  inline void ParCompactionManager::FollowStackClosure::do_void() {
    _compaction_manager->follow_marking_stacks();
  }
  
- inline void ParCompactionManager::follow_class_loader(ClassLoaderData* cld) {
-   MarkAndPushClosure mark_and_push_closure(this);
- 
-   cld->oops_do(&mark_and_push_closure, true);
- }
  
- inline void ParCompactionManager::follow_contents(oop obj) {
-   assert(PSParallelCompact::mark_bitmap()->is_marked(obj), "should be marked");
-   obj->pc_follow_contents(this);
- }
  
! template <class T>
! inline void oop_pc_follow_contents_specialized(objArrayOop obj, int index, ParCompactionManager* cm) {
    const size_t len = size_t(obj->length());
    const size_t beg_index = size_t(index);
    assert(beg_index < len || len == 0, "index too large");
  
    const size_t stride = MIN2(len - beg_index, (size_t)ObjArrayMarkingStride);
--- 83,105 ----
        push(obj);
      }
    }
  }
  
  inline void ParCompactionManager::follow_klass(Klass* klass) {
    oop holder = klass->klass_holder();
    mark_and_push(&holder);
  }
  
  inline void ParCompactionManager::FollowStackClosure::do_void() {
    _compaction_manager->follow_marking_stacks();
  }
  
  
  
! template <typename T>
! inline void follow_array_specialized(objArrayOop obj, int index, ParCompactionManager* cm) {
    const size_t len = size_t(obj->length());
    const size_t beg_index = size_t(index);
    assert(beg_index < len || len == 0, "index too large");
  
    const size_t stride = MIN2(len - beg_index, (size_t)ObjArrayMarkingStride);
***************
*** 132,149 ****
    for (T* e = beg; e < end; e++) {
      cm->mark_and_push<T>(e);
    }
  }
  
! inline void ParCompactionManager::follow_contents(objArrayOop obj, int index) {
    if (UseCompressedOops) {
!     oop_pc_follow_contents_specialized<narrowOop>(obj, index, this);
    } else {
!     oop_pc_follow_contents_specialized<oop>(obj, index, this);
    }
  }
  
  inline void ParCompactionManager::update_contents(oop obj) {
    obj->pc_update_contents(this);
  }
  
  #endif // SHARE_VM_GC_PARALLEL_PSCOMPACTIONMANAGER_INLINE_HPP
--- 116,179 ----
    for (T* e = beg; e < end; e++) {
      cm->mark_and_push<T>(e);
    }
  }
  
! inline void ParCompactionManager::follow_array(objArrayOop obj, int index) {
    if (UseCompressedOops) {
!     follow_array_specialized<narrowOop>(obj, index, this);
    } else {
!     follow_array_specialized<oop>(obj, index, this);
    }
  }
  
  inline void ParCompactionManager::update_contents(oop obj) {
    obj->pc_update_contents(this);
  }
  
+ class PSMarkAndPushClosure: public OopClosure {
+    private:
+     ParCompactionManager* _compaction_manager;
+    public:
+     PSMarkAndPushClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
+ 
+     template <typename T> void do_oop_nv(T* p)      { _compaction_manager->mark_and_push(p); }
+     virtual void do_oop(oop* p)                     { do_oop_nv(p); }
+     virtual void do_oop(narrowOop* p)               { do_oop_nv(p); }
+ 
+     // This closure provides its own oop verification code.
+     debug_only(virtual bool should_verify_oops()    { return false; })
+   };
+ 
+ class PSIterateMarkAndPushClosure: public MetadataVisitingOopIterateClosure {
+    private:
+     ParCompactionManager* _compaction_manager;
+    public:
+     PSIterateMarkAndPushClosure(ParCompactionManager* cm, ReferenceProcessor* rp) : MetadataVisitingOopIterateClosure(rp), _compaction_manager(cm) { }
+ 
+     template <typename T> void do_oop_nv(T* p)      { _compaction_manager->mark_and_push(p); }
+     virtual void do_oop(oop* p)                     { do_oop_nv(p); }
+     virtual void do_oop(narrowOop* p)               { do_oop_nv(p); }
+ 
+     void do_klass_nv(Klass* k)                      { _compaction_manager->follow_klass(k); }
+     void do_cld_nv(ClassLoaderData* cld)            { _compaction_manager->follow_class_loader(cld); }
+ 
+     // This closure provides its own oop verification code.
+     debug_only(virtual bool should_verify_oops()    { return false; })
+   };
+ 
+ inline void ParCompactionManager::follow_class_loader(ClassLoaderData* cld) {
+   PSMarkAndPushClosure mark_and_push_closure(this);
+   cld->oops_do(&mark_and_push_closure, true);
+ }
+ 
+ inline void ParCompactionManager::follow_contents(oop obj) {
+   assert(PSParallelCompact::mark_bitmap()->is_marked(obj), "should be marked");
+   if (obj->is_objArray()) {
+     follow_array(objArrayOop(obj), 0);
+   } else {
+     PSIterateMarkAndPushClosure cl(this, PSParallelCompact::ref_processor());
+     obj->oop_iterate(&cl);
+   }
+ }
+ 
  #endif // SHARE_VM_GC_PARALLEL_PSCOMPACTIONMANAGER_INLINE_HPP