src/hotspot/share/gc/shared/cardTableRS.hpp

@@ -30,11 +30,10 @@
 #include "oops/oop.hpp"
 
 class DirtyCardToOopClosure;
 class Generation;
 class Space;
-class OopsInGenClosure;
 
 // Helper to remember modified oops in all clds.
 class CLDRemSet {
   bool _accumulate_modified_oops;
  public:

@@ -102,21 +101,19 @@
   CardTableRS(MemRegion whole_heap, bool scanned_concurrently);
   ~CardTableRS();
 
   CLDRemSet* cld_rem_set() { return &_cld_rem_set; }
 
-  void younger_refs_in_space_iterate(Space* sp, OopsInGenClosure* cl, uint n_threads);
+  void younger_refs_in_space_iterate(Space* sp, HeapWord* gen_boundary, OopIterateClosure* cl, uint n_threads);
 
   virtual void verify_used_region_at_save_marks(Space* sp) const NOT_DEBUG_RETURN;
 
   // Override.
   void prepare_for_younger_refs_iterate(bool parallel);
 
-  // Card table entries are cleared before application; "blk" is
-  // responsible for dirtying if the oop is still older-to-younger after
-  // closure application.
-  void younger_refs_iterate(Generation* g, OopsInGenClosure* blk, uint n_threads);
+  // Card table entries are cleared before application;
+  void at_younger_refs_iterate();
 
   void inline_write_ref_field_gc(void* field, oop new_val) {
     CardValue* byte = byte_for(field);
     *byte = youngergen_card;
   }

@@ -163,18 +160,19 @@
   bool card_may_have_been_dirty(CardValue cv);
 
   // Iterate over the portion of the card-table which covers the given
   // region mr in the given space and apply cl to any dirty sub-regions
   // of mr. Clears the dirty cards as they are processed.
-  void non_clean_card_iterate_possibly_parallel(Space* sp, MemRegion mr,
-                                                OopsInGenClosure* cl, CardTableRS* ct,
+  void non_clean_card_iterate_possibly_parallel(Space* sp, HeapWord* gen_boundary,
+                                                MemRegion mr,
+                                                OopIterateClosure* cl, CardTableRS* ct,
                                                 uint n_threads);
 
   // Work method used to implement non_clean_card_iterate_possibly_parallel()
   // above in the parallel case.
   virtual void non_clean_card_iterate_parallel_work(Space* sp, MemRegion mr,
-                                                    OopsInGenClosure* cl, CardTableRS* ct,
+                                                    OopIterateClosure* cl, CardTableRS* ct,
                                                     uint n_threads);
 
   // This is an array, one element per covered region of the card table.
   // Each entry is itself an array, with one element per chunk in the
   // covered region.  Each entry of these arrays is the lowest non-clean