src/share/vm/gc/cms/cmsOopClosures.hpp

@@ -35,11 +35,11 @@
 class ConcurrentMarkSweepGeneration;
 class CMSBitMap;
 class CMSMarkStack;
 class CMSCollector;
 class MarkFromRootsClosure;
-class Par_MarkFromRootsClosure;
+class ParMarkFromRootsClosure;
 
 // Decode the oop and call do_oop on it.
 #define DO_OOP_WORK_DEFN \
   void do_oop(oop obj);                                   \
   template <class T> inline void do_oop_work(T* p) {      \

@@ -80,18 +80,18 @@
   MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap);
   virtual void do_oop(oop* p);
   virtual void do_oop(narrowOop* p);
 };
 
-class Par_MarkRefsIntoClosure: public MetadataAwareOopsInGenClosure {
+class ParMarkRefsIntoClosure: public MetadataAwareOopsInGenClosure {
  private:
   const MemRegion _span;
   CMSBitMap*      _bitMap;
  protected:
   DO_OOP_WORK_DEFN
  public:
-  Par_MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap);
+  ParMarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap);
   virtual void do_oop(oop* p);
   virtual void do_oop(narrowOop* p);
 };
 
 // A variant of the above used in certain kinds of CMS

@@ -139,28 +139,28 @@
 // reference processor are currently all shared. Access to
 // these shared mutable structures must use appropriate
 // synchronization (for instance, via CAS). The marking stack
 // used in the non-parallel case above is here replaced with
 // an OopTaskQueue structure to allow efficient work stealing.
-class Par_PushAndMarkClosure: public MetadataAwareOopClosure {
+class ParPushAndMarkClosure: public MetadataAwareOopClosure {
  private:
   CMSCollector* _collector;
   MemRegion     _span;
   CMSBitMap*    _bit_map;
   OopTaskQueue* _work_queue;
  protected:
   DO_OOP_WORK_DEFN
  public:
-  Par_PushAndMarkClosure(CMSCollector* collector,
+  ParPushAndMarkClosure(CMSCollector* collector,
                          MemRegion span,
                          ReferenceProcessor* rp,
                          CMSBitMap* bit_map,
                          OopTaskQueue* work_queue);
   virtual void do_oop(oop* p);
   virtual void do_oop(narrowOop* p);
-  inline void do_oop_nv(oop* p)       { Par_PushAndMarkClosure::do_oop_work(p); }
-  inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
+  inline void do_oop_nv(oop* p)       { ParPushAndMarkClosure::do_oop_work(p); }
+  inline void do_oop_nv(narrowOop* p) { ParPushAndMarkClosure::do_oop_work(p); }
 };
 
 // The non-parallel version (the parallel version appears further below).
 class MarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure {
  private:

@@ -201,29 +201,29 @@
 
 // In this, the parallel avatar of MarkRefsIntoAndScanClosure, the revisit
 // stack and the bitMap are shared, so access needs to be suitably
 // synchronized. An OopTaskQueue structure, supporting efficient
 // work stealing, replaces a CMSMarkStack for storing grey objects.
-class Par_MarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure {
+class ParMarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure {
  private:
   MemRegion              _span;
   CMSBitMap*             _bit_map;
   OopTaskQueue*          _work_queue;
   const uint             _low_water_mark;
-  Par_PushAndMarkClosure _par_pushAndMarkClosure;
+  ParPushAndMarkClosure _parPushAndMarkClosure;
  protected:
   DO_OOP_WORK_DEFN
  public:
-  Par_MarkRefsIntoAndScanClosure(CMSCollector* collector,
+  ParMarkRefsIntoAndScanClosure(CMSCollector* collector,
                                  MemRegion span,
                                  ReferenceProcessor* rp,
                                  CMSBitMap* bit_map,
                                  OopTaskQueue* work_queue);
   virtual void do_oop(oop* p);
   virtual void do_oop(narrowOop* p);
-  inline void do_oop_nv(oop* p)       { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
-  inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
+  inline void do_oop_nv(oop* p)       { ParMarkRefsIntoAndScanClosure::do_oop_work(p); }
+  inline void do_oop_nv(narrowOop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); }
 
   void trim_queue(uint size);
 };
 
 // This closure is used during the concurrent marking phase

@@ -259,38 +259,38 @@
 };
 
 // A parallel (MT) version of the above.
 // This closure is used during the concurrent marking phase
 // following the first checkpoint. Its use is buried in
-// the closure Par_MarkFromRootsClosure.
-class Par_PushOrMarkClosure: public MetadataAwareOopClosure {
+// the closure ParMarkFromRootsClosure.
+class ParPushOrMarkClosure: public MetadataAwareOopClosure {
  private:
   CMSCollector*    _collector;
   MemRegion        _whole_span;
   MemRegion        _span;        // local chunk
   CMSBitMap*       _bit_map;
   OopTaskQueue*    _work_queue;
   CMSMarkStack*    _overflow_stack;
   HeapWord*  const _finger;
   HeapWord** const _global_finger_addr;
-  Par_MarkFromRootsClosure* const
+  ParMarkFromRootsClosure* const
                    _parent;
  protected:
   DO_OOP_WORK_DEFN
  public:
-  Par_PushOrMarkClosure(CMSCollector* cms_collector,
+  ParPushOrMarkClosure(CMSCollector* cms_collector,
                         MemRegion span,
                         CMSBitMap* bit_map,
                         OopTaskQueue* work_queue,
                         CMSMarkStack* mark_stack,
                         HeapWord* finger,
                         HeapWord** global_finger_addr,
-                        Par_MarkFromRootsClosure* parent);
+                       ParMarkFromRootsClosure* parent);
   virtual void do_oop(oop* p);
   virtual void do_oop(narrowOop* p);
-  inline void do_oop_nv(oop* p)       { Par_PushOrMarkClosure::do_oop_work(p); }
-  inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
+  inline void do_oop_nv(oop* p)       { ParPushOrMarkClosure::do_oop_work(p); }
+  inline void do_oop_nv(narrowOop* p) { ParPushOrMarkClosure::do_oop_work(p); }
 
   // Deal with a stack overflow condition
   void handle_stack_overflow(HeapWord* lost);
  private:
   inline void do_yield_check();