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

8211446_01: revision due to comments from StefanJ and Thomas

 #include "oops/objArrayOop.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 
+class PCMarkAndPushClosure: public OopClosure {
+private:
+  ParCompactionManager* _compaction_manager;
+public:
+  PCMarkAndPushClosure(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 PCIterateMarkAndPushClosure: public MetadataVisitingOopIterateClosure {
+private:
+  ParCompactionManager* _compaction_manager;
+public:
+  PCIterateMarkAndPushClosure(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 bool ParCompactionManager::steal(int queue_num, oop& t) {
   return stack_array()->steal(queue_num, t);
 }
 
 inline bool ParCompactionManager::steal_objarray(int queue_num, ObjArrayTask& t) {

@@ -92,12 +123,10
 
 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");

@@ -128,52 +157,21
 
 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);
+  PCMarkAndPushClosure 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());
+    PCIterateMarkAndPushClosure cl(this, PSParallelCompact::ref_processor());
     obj->oop_iterate(&cl);
   }
 }
 
 #endif // SHARE_VM_GC_PARALLEL_PSCOMPACTIONMANAGER_INLINE_HPP