hotspot/src/share/vm/memory/genOopClosures.hpp

rev 611 : Merge

@@ -1,10 +1,10 @@
 #ifdef USE_PRAGMA_IDENT_HDR
 #pragma ident "@(#)genOopClosures.hpp   1.64 07/05/29 09:44:15 JVM"
 #endif
 /*
- * Copyright 2001-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2001-2008 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.

@@ -29,10 +29,15 @@
 class HeapWord;
 class CardTableRS;
 class CardTableModRefBS;
 class DefNewGeneration;
 
+template<class E> class GenericTaskQueue;
+typedef GenericTaskQueue<oop> OopTaskQueue;
+template<class E> class GenericTaskQueueSet;
+typedef GenericTaskQueueSet<oop> OopTaskQueueSet;
+
 // Closure for iterating roots from a particular generation
 // Note: all classes deriving from this MUST call this do_barrier
 // method at the end of their own do_oop method!
 // Note: no do_oop defined, this is an abstract class.
 

@@ -50,11 +55,14 @@
   Generation* generation() { return _gen; }
   CardTableRS* rs() { return _rs; }
  
   // Derived classes that modify oops so that they might be old-to-young
   // pointers must call the method below.
-  void do_barrier(oop* p);
+  template <class T> void do_barrier(T* p);
+
+  // Version for use by closures that may be called in parallel code.
+  void par_do_barrier(oop* p);
 
  public:
   OopsInGenClosure() : OopClosure(NULL),
     _orig_gen(NULL), _gen(NULL), _gen_boundary(NULL), _rs(NULL) {};
 

@@ -76,18 +84,21 @@
 // Closure for scanning DefNewGeneration.
 //
 // This closure will perform barrier store calls for ALL
 // pointers in scanned oops.
 class ScanClosure: public OopsInGenClosure {
-protected:
+ protected:
   DefNewGeneration* _g;
   HeapWord* _boundary;
   bool _gc_barrier;
-public:
+  template <class T> inline void do_oop_work(T* p);
+ public:
   ScanClosure(DefNewGeneration* g, bool gc_barrier);
-  void do_oop(oop* p);
-  void do_oop_nv(oop* p);
+  virtual void do_oop(oop* p);
+  virtual void do_oop(narrowOop* p);
+  inline void do_oop_nv(oop* p);
+  inline void do_oop_nv(narrowOop* p);
   bool do_header() { return false; }
   Prefetch::style prefetch_style() {
     return Prefetch::do_write;
   } 
 };

@@ -96,57 +107,75 @@
 //
 // This closure only performs barrier store calls on
 // pointers into the DefNewGeneration. This is less
 // precise, but faster, than a ScanClosure
 class FastScanClosure: public OopsInGenClosure {
-protected:
+ protected:
   DefNewGeneration* _g;
   HeapWord* _boundary;
   bool _gc_barrier;
-public:
+  template <class T> inline void do_oop_work(T* p);
+ public:
   FastScanClosure(DefNewGeneration* g, bool gc_barrier);
-  void do_oop(oop* p);
-  void do_oop_nv(oop* p);
+  virtual void do_oop(oop* p);
+  virtual void do_oop(narrowOop* p);
+  inline void do_oop_nv(oop* p);
+  inline void do_oop_nv(narrowOop* p);
   bool do_header() { return false; }
   Prefetch::style prefetch_style() {
     return Prefetch::do_write;
   } 
 };
 
 class FilteringClosure: public OopClosure {
+ private:
   HeapWord* _boundary;
   OopClosure* _cl;
-public:
-  FilteringClosure(HeapWord* boundary, OopClosure* cl) :
-    OopClosure(cl->_ref_processor), _boundary(boundary),
-    _cl(cl) {}
-  void do_oop(oop* p);
-  void do_oop_nv(oop* p) {
-    oop obj = *p;
-    if ((HeapWord*)obj < _boundary && obj != NULL) {
+ protected:
+  template <class T> inline void do_oop_work(T* p) {
+    T heap_oop = oopDesc::load_heap_oop(p);
+    if (!oopDesc::is_null(heap_oop)) {
+      oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
+      if ((HeapWord*)obj < _boundary) {
       _cl->do_oop(p);
     }
   }
+  }
+ public:
+  FilteringClosure(HeapWord* boundary, OopClosure* cl) :
+    OopClosure(cl->_ref_processor), _boundary(boundary),
+    _cl(cl) {}
+  virtual void do_oop(oop* p);
+  virtual void do_oop(narrowOop* p);
+  inline void do_oop_nv(oop* p)       { FilteringClosure::do_oop_work(p); }
+  inline void do_oop_nv(narrowOop* p) { FilteringClosure::do_oop_work(p); }
   bool do_header() { return false; }
 };
 
 // Closure for scanning DefNewGeneration's weak references.
 // NOTE: very much like ScanClosure but not derived from
 //  OopsInGenClosure -- weak references are processed all
 //  at once, with no notion of which generation they were in.
 class ScanWeakRefClosure: public OopClosure {
-protected:
+ protected:
   DefNewGeneration*  _g;
   HeapWord*          _boundary;
-public:
+  template <class T> inline void do_oop_work(T* p);
+ public:
   ScanWeakRefClosure(DefNewGeneration* g);
-  void do_oop(oop* p);
-  void do_oop_nv(oop* p);
+  virtual void do_oop(oop* p);
+  virtual void do_oop(narrowOop* p);
+  inline void do_oop_nv(oop* p);
+  inline void do_oop_nv(narrowOop* p);
 };
 
 class VerifyOopClosure: public OopClosure {
-public: 
-  void do_oop(oop* p) {
-    guarantee((*p)->is_oop_or_null(), "invalid oop");
+ protected:
+  template <class T> inline void do_oop_work(T* p) {
+    oop obj = oopDesc::load_decode_heap_oop(p);
+    guarantee(obj->is_oop_or_null(), "invalid oop");
   }
+ public:
+  virtual void do_oop(oop* p);
+  virtual void do_oop(narrowOop* p);
   static VerifyOopClosure verify_oop;
 };