src/share/vm/gc/shared/space.hpp

rev 12906 : [mq]: gc_interface

*** 24,34 ****
  
  #ifndef SHARE_VM_GC_SHARED_SPACE_HPP
  #define SHARE_VM_GC_SHARED_SPACE_HPP
  
  #include "gc/shared/blockOffsetTable.hpp"
! #include "gc/shared/cardTableModRefBS.hpp"
  #include "gc/shared/workgroup.hpp"
  #include "memory/allocation.hpp"
  #include "memory/iterator.hpp"
  #include "memory/memRegion.hpp"
  #include "oops/markOop.hpp"
--- 24,34 ----
  
  #ifndef SHARE_VM_GC_SHARED_SPACE_HPP
  #define SHARE_VM_GC_SHARED_SPACE_HPP
  
  #include "gc/shared/blockOffsetTable.hpp"
! #include "gc/shared/cardTable.hpp"
  #include "gc/shared/workgroup.hpp"
  #include "memory/allocation.hpp"
  #include "memory/iterator.hpp"
  #include "memory/memRegion.hpp"
  #include "oops/markOop.hpp"
*** 178,188 ****
    // Create and return a new dirty card to oop closure. Can be
    // overridden to return the appropriate type of closure
    // depending on the type of space in which the closure will
    // operate. ResourceArea allocated.
    virtual DirtyCardToOopClosure* new_dcto_cl(ExtendedOopClosure* cl,
!                                              CardTableModRefBS::PrecisionStyle precision,
                                               HeapWord* boundary,
                                               bool parallel);
  
    // If "p" is in the space, returns the address of the start of the
    // "block" that contains "p".  We say "block" instead of "object" since
--- 178,188 ----
    // Create and return a new dirty card to oop closure. Can be
    // overridden to return the appropriate type of closure
    // depending on the type of space in which the closure will
    // operate. ResourceArea allocated.
    virtual DirtyCardToOopClosure* new_dcto_cl(ExtendedOopClosure* cl,
!                                              CardTable::PrecisionStyle precision,
                                               HeapWord* boundary,
                                               bool parallel);
  
    // If "p" is in the space, returns the address of the start of the
    // "block" that contains "p".  We say "block" instead of "object" since
*** 250,260 ****
  
  class DirtyCardToOopClosure: public MemRegionClosureRO {
  protected:
    ExtendedOopClosure* _cl;
    Space* _sp;
!   CardTableModRefBS::PrecisionStyle _precision;
    HeapWord* _boundary;          // If non-NULL, process only non-NULL oops
                                  // pointing below boundary.
    HeapWord* _min_done;          // ObjHeadPreciseArray precision requires
                                  // a downwards traversal; this is the
                                  // lowest location already done (or,
--- 250,260 ----
  
  class DirtyCardToOopClosure: public MemRegionClosureRO {
  protected:
    ExtendedOopClosure* _cl;
    Space* _sp;
!   CardTable::PrecisionStyle _precision;
    HeapWord* _boundary;          // If non-NULL, process only non-NULL oops
                                  // pointing below boundary.
    HeapWord* _min_done;          // ObjHeadPreciseArray precision requires
                                  // a downwards traversal; this is the
                                  // lowest location already done (or,
*** 279,289 ****
    // or possibly more efficient walking.
    virtual void walk_mem_region(MemRegion mr, HeapWord* bottom, HeapWord* top);
  
  public:
    DirtyCardToOopClosure(Space* sp, ExtendedOopClosure* cl,
!                         CardTableModRefBS::PrecisionStyle precision,
                          HeapWord* boundary) :
      _sp(sp), _cl(cl), _precision(precision), _boundary(boundary),
      _min_done(NULL) {
      NOT_PRODUCT(_last_bottom = NULL);
      NOT_PRODUCT(_last_explicit_min_done = NULL);
--- 279,289 ----
    // or possibly more efficient walking.
    virtual void walk_mem_region(MemRegion mr, HeapWord* bottom, HeapWord* top);
  
  public:
    DirtyCardToOopClosure(Space* sp, ExtendedOopClosure* cl,
!                         CardTable::PrecisionStyle precision,
                          HeapWord* boundary) :
      _sp(sp), _cl(cl), _precision(precision), _boundary(boundary),
      _min_done(NULL) {
      NOT_PRODUCT(_last_bottom = NULL);
      NOT_PRODUCT(_last_explicit_min_done = NULL);
*** 613,623 ****
      set_concurrent_iteration_safe_limit(compaction_top());
    }
  
    // Override.
    DirtyCardToOopClosure* new_dcto_cl(ExtendedOopClosure* cl,
!                                      CardTableModRefBS::PrecisionStyle precision,
                                       HeapWord* boundary,
                                       bool parallel);
  
    // Apply "blk->do_oop" to the addresses of all reference fields in objects
    // starting with the _saved_mark_word, which was noted during a generation's
--- 613,623 ----
      set_concurrent_iteration_safe_limit(compaction_top());
    }
  
    // Override.
    DirtyCardToOopClosure* new_dcto_cl(ExtendedOopClosure* cl,
!                                      CardTable::PrecisionStyle precision,
                                       HeapWord* boundary,
                                       bool parallel);
  
    // Apply "blk->do_oop" to the addresses of all reference fields in objects
    // starting with the _saved_mark_word, which was noted during a generation's
*** 688,698 ****
                                         HeapWord* bottom, HeapWord* top,
                                         FilteringClosure* cl) = 0;
  
  public:
    FilteringDCTOC(Space* sp, ExtendedOopClosure* cl,
!                   CardTableModRefBS::PrecisionStyle precision,
                    HeapWord* boundary) :
      DirtyCardToOopClosure(sp, cl, precision, boundary) {}
  };
  
  // A dirty card to oop closure for contiguous spaces
--- 688,698 ----
                                         HeapWord* bottom, HeapWord* top,
                                         FilteringClosure* cl) = 0;
  
  public:
    FilteringDCTOC(Space* sp, ExtendedOopClosure* cl,
!                   CardTable::PrecisionStyle precision,
                    HeapWord* boundary) :
      DirtyCardToOopClosure(sp, cl, precision, boundary) {}
  };
  
  // A dirty card to oop closure for contiguous spaces
*** 717,727 ****
                                         HeapWord* bottom, HeapWord* top,
                                         FilteringClosure* cl);
  
  public:
    ContiguousSpaceDCTOC(ContiguousSpace* sp, ExtendedOopClosure* cl,
!                        CardTableModRefBS::PrecisionStyle precision,
                         HeapWord* boundary) :
      FilteringDCTOC(sp, cl, precision, boundary)
    {}
  };
  
--- 717,727 ----
                                         HeapWord* bottom, HeapWord* top,
                                         FilteringClosure* cl);
  
  public:
    ContiguousSpaceDCTOC(ContiguousSpace* sp, ExtendedOopClosure* cl,
!                        CardTable::PrecisionStyle precision,
                         HeapWord* boundary) :
      FilteringDCTOC(sp, cl, precision, boundary)
    {}
  };