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

rev 49944 : imported patch 8201492-properly-implement-non-contiguous-reference-processing
rev 49945 : imported patch 8201492-stefanj-review

@@ -327,12 +327,12 @@
   void balance_queues(DiscoveredList ref_lists[]);
 
   // Update (advance) the soft ref master clock field.
   void update_soft_ref_master_clock();
 
-  template <class T>
-  bool is_subject_to_discovery(T const obj) const;
+  bool is_subject_to_discovery(oop const obj) const;
+
 public:
   // Default parameters give you a vanilla reference processor.
   ReferenceProcessor(BoolObjectClosure* is_subject_to_discovery,
                      bool mt_processing = false, uint mt_processing_degree = 1,
                      bool mt_discovery  = false, uint mt_discovery_degree  = 1,

@@ -417,35 +417,28 @@
   // debugging
   void verify_no_references_recorded() PRODUCT_RETURN;
   void verify_referent(oop obj)        PRODUCT_RETURN;
 };
 
-// A reference processor that uses a single memory span to determine the area that
+// A subject-to-discovery closure that uses a single memory span to determine the area that
 // is subject to discovery. Useful for collectors which have contiguous generations.
-class SpanReferenceProcessor : public ReferenceProcessor {
-  class SpanBasedDiscoverer : public BoolObjectClosure {
-  public:
+class SpanSubjectToDiscoveryClosure : public BoolObjectClosure {
     MemRegion _span;
 
-    SpanBasedDiscoverer(MemRegion span) : BoolObjectClosure(), _span(span) { }
+public:
+  SpanSubjectToDiscoveryClosure() : BoolObjectClosure(), _span() { }
+  SpanSubjectToDiscoveryClosure(MemRegion span) : BoolObjectClosure(), _span(span) { }
+
+  MemRegion span() const { return _span; }
+
+  void set_span(MemRegion mr) {
+    _span = mr;
+  }
 
     virtual bool do_object_b(oop obj) {
       return _span.contains(obj);
     }
-  };
-
-  SpanBasedDiscoverer _span_based_discoverer;
-public:
-  SpanReferenceProcessor(MemRegion span,
-                              bool mt_processing = false, uint mt_processing_degree = 1,
-                              bool mt_discovery  = false, uint mt_discovery_degree  = 1,
-                              bool atomic_discovery = true,
-                              BoolObjectClosure* is_alive_non_header = NULL);
-
-  // get and set span
-  MemRegion span()                   { return _span_based_discoverer._span; }
-  void      set_span(MemRegion span) { _span_based_discoverer._span = span; }
 };
 
 // A utility class to disable reference discovery in
 // the scope which contains it, for given ReferenceProcessor.
 class NoRefDiscovery: StackObj {

@@ -468,15 +461,14 @@
 };
 
 // A utility class to temporarily mutate the subject discovery closure of the
 // given ReferenceProcessor in the scope that contains it.
 class ReferenceProcessorSubjectToDiscoveryMutator : StackObj {
- private:
   ReferenceProcessor* _rp;
   BoolObjectClosure* _saved_cl;
 
- public:
+public:
   ReferenceProcessorSubjectToDiscoveryMutator(ReferenceProcessor* rp, BoolObjectClosure* cl):
     _rp(rp) {
     _saved_cl = _rp->is_subject_to_discovery_closure();
     _rp->set_is_subject_to_discovery_closure(cl);
   }

@@ -486,25 +478,25 @@
   }
 };
 
 // A utility class to temporarily mutate the span of the
 // given ReferenceProcessor in the scope that contains it.
-class ReferenceProcessorSpanMutator: StackObj {
- private:
-  SpanReferenceProcessor* _rp;
-  MemRegion _saved_span;
+class ReferenceProcessorSpanMutator : StackObj {
+  ReferenceProcessor* _rp;
+  SpanSubjectToDiscoveryClosure _discoverer;
+  BoolObjectClosure* _old_discoverer;
 
- public:
-  ReferenceProcessorSpanMutator(SpanReferenceProcessor* rp,
+public:
+  ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
                                 MemRegion span):
-    _rp(rp) {
-    _saved_span = _rp->span();
-    _rp->set_span(span);
+    _rp(rp), _discoverer(span) {
+    _old_discoverer = rp->is_subject_to_discovery_closure();
+    rp->set_is_subject_to_discovery_closure(&_discoverer);
   }
 
   ~ReferenceProcessorSpanMutator() {
-    _rp->set_span(_saved_span);
+    _rp->set_is_subject_to_discovery_closure(_old_discoverer);
   }
 };
 
 // A utility class to temporarily change the MT'ness of
 // reference discovery for the given ReferenceProcessor