src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp

*** 931,959 ****
    class IsAliveClosure: public BoolObjectClosure {
     public:
      virtual bool do_object_b(oop p);
    };
  
-   class KeepAliveClosure: public OopClosure {
-    private:
-     ParCompactionManager* _compaction_manager;
-    protected:
-     template <class T> inline void do_oop_work(T* p);
-    public:
-     KeepAliveClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
-     virtual void do_oop(oop* p);
-     virtual void do_oop(narrowOop* p);
-   };
- 
-   class FollowStackClosure: public VoidClosure {
-    private:
-     ParCompactionManager* _compaction_manager;
-    public:
-     FollowStackClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
-     virtual void do_void();
-   };
- 
    class AdjustPointerClosure: public ExtendedOopClosure {
     public:
      template <typename T> void do_oop_nv(T* p);
      virtual void do_oop(oop* p);
      virtual void do_oop(narrowOop* p);
--- 931,940 ----
*** 965,975 ****
    class AdjustKlassClosure : public KlassClosure {
     public:
      void do_klass(Klass* klass);
    };
  
-   friend class KeepAliveClosure;
    friend class FollowStackClosure;
    friend class AdjustPointerClosure;
    friend class AdjustKlassClosure;
    friend class FollowKlassClosure;
    friend class InstanceClassLoaderKlass;
--- 946,955 ----
*** 1140,1173 ****
  
    // Reset time since last full gc
    static void reset_millis_since_last_gc();
  
   public:
-   class MarkAndPushClosure: public ExtendedOopClosure {
-    private:
-     ParCompactionManager* _compaction_manager;
-    public:
-     MarkAndPushClosure(ParCompactionManager* cm) : _compaction_manager(cm) { }
- 
-     template <typename T> void do_oop_nv(T* p);
-     virtual void do_oop(oop* p);
-     virtual void do_oop(narrowOop* p);
- 
-     // This closure provides its own oop verification code.
-     debug_only(virtual bool should_verify_oops() { return false; })
-   };
- 
-   // The one and only place to start following the classes.
-   // Should only be applied to the ClassLoaderData klasses list.
-   class FollowKlassClosure : public KlassClosure {
-    private:
-     MarkAndPushClosure* _mark_and_push_closure;
-    public:
-     FollowKlassClosure(MarkAndPushClosure* mark_and_push_closure) :
-         _mark_and_push_closure(mark_and_push_closure) { }
-     void do_klass(Klass* klass);
-   };
  
    PSParallelCompact();
  
    static void invoke(bool maximum_heap_compaction);
    static bool invoke_no_policy(bool maximum_heap_compaction);
--- 1120,1129 ----
*** 1198,1213 ****
    }
  
    // Marking support
    static inline bool mark_obj(oop obj);
    static inline bool is_marked(oop obj);
-   // Check mark and maybe push on marking stack
-   template <class T> static inline void mark_and_push(ParCompactionManager* cm,
-                                                       T* p);
-   template <class T> static inline void adjust_pointer(T* p);
  
!   static inline void follow_klass(ParCompactionManager* cm, Klass* klass);
  
    static void follow_class_loader(ParCompactionManager* cm,
                                    ClassLoaderData* klass);
  
    // Compaction support.
--- 1154,1165 ----
    }
  
    // Marking support
    static inline bool mark_obj(oop obj);
    static inline bool is_marked(oop obj);
  
!   template <class T> static inline void adjust_pointer(T* p);
  
    static void follow_class_loader(ParCompactionManager* cm,
                                    ClassLoaderData* klass);
  
    // Compaction support.
*** 1335,1349 ****
  
  inline bool PSParallelCompact::is_marked(oop obj) {
    return mark_bitmap()->is_marked(obj);
  }
  
- template <class T>
- inline void PSParallelCompact::KeepAliveClosure::do_oop_work(T* p) {
-   mark_and_push(_compaction_manager, p);
- }
- 
  inline bool PSParallelCompact::print_phases() {
    return _print_phases;
  }
  
  inline double PSParallelCompact::normal_distribution(double density) {
--- 1287,1296 ----