src/share/vm/memory/referenceProcessor.hpp

rev 2518 : [mq]: g1-reference-processing

*** 46,86 ****
  // (with appropriate modifications) to any "non-convex interval".
  
  // forward references
  class ReferencePolicy;
  class AbstractRefProcTaskExecutor;
! class DiscoveredList;
  
  class ReferenceProcessor : public CHeapObj {
   protected:
    // End of list marker
    static oop  _sentinelRef;
    MemRegion   _span; // (right-open) interval of heap
                       // subject to wkref discovery
    bool        _discovering_refs;      // true when discovery enabled
    bool        _discovery_is_atomic;   // if discovery is atomic wrt
                                        // other collectors in configuration
    bool        _discovery_is_mt;       // true if reference discovery is MT.
    // If true, setting "next" field of a discovered refs list requires
    // write barrier(s).  (Must be true if used in a collector in which
    // elements of a discovered list may be moved during discovery: for
    // example, a collector like Garbage-First that moves objects during a
    // long-term concurrent marking phase that does weak reference
    // discovery.)
    bool        _discovered_list_needs_barrier;
    BarrierSet* _bs;                    // Cached copy of BarrierSet.
    bool        _enqueuing_is_done;     // true if all weak references enqueued
    bool        _processing_is_mt;      // true during phases when
                                        // reference processing is MT.
    int         _next_id;               // round-robin mod _num_q counter in
                                        // support of work distribution
  
!   // For collectors that do not keep GC marking information
    // in the object header, this field holds a closure that
    // helps the reference processor determine the reachability
    // of an oop (the field is currently initialized to NULL for
!   // all collectors but the CMS collector).
    BoolObjectClosure* _is_alive_non_header;
  
    // Soft ref clearing policies
    // . the default policy
    static ReferencePolicy*   _default_soft_ref_policy;
--- 46,125 ----
  // (with appropriate modifications) to any "non-convex interval".
  
  // forward references
  class ReferencePolicy;
  class AbstractRefProcTaskExecutor;
! 
! // List of discovered references.
! class DiscoveredList {
!  public:
!   DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
!   oop head() const     {
!      return UseCompressedOops ?  oopDesc::decode_heap_oop_not_null(_compressed_head) :
!                                 _oop_head;
!   }
!   HeapWord* adr_head() {
!     return UseCompressedOops ? (HeapWord*)&_compressed_head :
!                                (HeapWord*)&_oop_head;
!   }
!   void   set_head(oop o) {
!     if (UseCompressedOops) {
!       // Must compress the head ptr.
!       _compressed_head = oopDesc::encode_heap_oop_not_null(o);
!     } else {
!       _oop_head = o;
!     }
!   }
! 
!   bool empty() const; 
! 
!   size_t length()               { return _len; }
!   void   set_length(size_t len) { _len = len;  }
!   void   inc_length(size_t inc) { _len += inc; assert(_len > 0, "Error"); }
!   void   dec_length(size_t dec) { _len -= dec; }
! 
!  private:
!   // Set value depending on UseCompressedOops. This could be a template class
!   // but then we have to fix all the instantiations and declarations that use this class.
!   oop       _oop_head;
!   narrowOop _compressed_head;
!   size_t _len;
! };
  
  class ReferenceProcessor : public CHeapObj {
   protected:
    // End of list marker
    static oop  _sentinelRef;
+ 
    MemRegion   _span;                    // (right-open) interval of heap
                                          // subject to wkref discovery
+ 
    bool        _discovering_refs;        // true when discovery enabled
    bool        _discovery_is_atomic;     // if discovery is atomic wrt
                                          // other collectors in configuration
    bool        _discovery_is_mt;         // true if reference discovery is MT.
+ 
    // If true, setting "next" field of a discovered refs list requires
    // write barrier(s).  (Must be true if used in a collector in which
    // elements of a discovered list may be moved during discovery: for
    // example, a collector like Garbage-First that moves objects during a
    // long-term concurrent marking phase that does weak reference
    // discovery.)
    bool        _discovered_list_needs_barrier;
+ 
    BarrierSet* _bs;                      // Cached copy of BarrierSet.
    bool        _enqueuing_is_done;       // true if all weak references enqueued
    bool        _processing_is_mt;        // true during phases when
                                          // reference processing is MT.
    int         _next_id;                 // round-robin mod _num_q counter in
                                          // support of work distribution
  
!   // For collectors that do not keep GC liveness information
    // in the object header, this field holds a closure that
    // helps the reference processor determine the reachability
    // of an oop (the field is currently initialized to NULL for
!   // all collectors but the CMS G1 collectors).
    BoolObjectClosure* _is_alive_non_header;
  
    // Soft ref clearing policies
    // . the default policy
    static ReferencePolicy*   _default_soft_ref_policy;
*** 100,109 ****
--- 139,150 ----
    DiscoveredList* _discoveredWeakRefs;
    DiscoveredList* _discoveredFinalRefs;
    DiscoveredList* _discoveredPhantomRefs;
  
   public:
+   static int subclasses_of_ref()         { return (REF_PHANTOM - REF_OTHER); }
+ 
    int num_q()                            { return _num_q; }
    int max_num_q()                        { return _max_num_q; }
    void set_active_mt_degree(int v)       { _num_q = v; }
    DiscoveredList* discovered_soft_refs() { return _discoveredSoftRefs; }
    static oop  sentinel_ref()             { return _sentinelRef; }