8367240: Parallel: Refactor PSScavengeCLDClosure

Reviewed-by: stefank

Author: albertnetymk

src/hotspot/share/gc/parallel/psClosure.inline.hpp

@@ -78,16 +78,17 @@ typedef PSRootsClosure</*promote_immediately=*/false> PSScavengeRootsClosure;
 typedef PSRootsClosure</*promote_immediately=*/true> PSPromoteRootsClosure;
 
 // Scavenges a single oop in a ClassLoaderData.
-class PSScavengeFromCLDClosure: public OopClosure {
-private:
+class PSScavengeCLDOopClosure : public OopClosure {
   PSPromotionManager* _pm;
-  // Used to redirty a scanned cld if it has oops
-  // pointing to the young generation after being scanned.
-  ClassLoaderData*    _scanned_cld;
+
 public:
-  PSScavengeFromCLDClosure(PSPromotionManager* pm) : _pm(pm), _scanned_cld(nullptr) { }
+  // Records whether this CLD contains oops pointing into young-gen after scavenging.
+  bool _has_oops_into_young_gen;
+
+  PSScavengeCLDOopClosure(PSPromotionManager* pm) : _pm(pm), _has_oops_into_young_gen(false) {}
+
   void do_oop(narrowOop* p) { ShouldNotReachHere(); }
-  void do_oop(oop* p)       {
+  void do_oop(oop* p) {
     ParallelScavengeHeap* psh = ParallelScavengeHeap::heap();
     assert(!psh->is_in_reserved(p), "GC barrier needed");
     if (PSScavenge::should_scavenge(p)) {
@@ -97,43 +98,33 @@ class PSScavengeFromCLDClosure: public OopClosure {
       oop new_obj = _pm->copy_to_survivor_space</*promote_immediately=*/false>(o);
       RawAccess<IS_NOT_NULL>::oop_store(p, new_obj);
 
-      if (PSScavenge::is_obj_in_young(new_obj)) {
-        do_cld_barrier();
+      if (PSScavenge::is_obj_in_young(new_obj) && !_has_oops_into_young_gen) {
+        _has_oops_into_young_gen = true;
       }
     }
   }
-
-  void set_scanned_cld(ClassLoaderData* cld) {
-    assert(_scanned_cld == nullptr || cld == nullptr, "Should always only handling one cld at a time");
-    _scanned_cld = cld;
-  }
-
-private:
-  void do_cld_barrier() {
-    assert(_scanned_cld != nullptr, "Should not be called without having a scanned cld");
-    _scanned_cld->record_modified_oops();
-  }
 };
 
 // Scavenges the oop in a ClassLoaderData.
 class PSScavengeCLDClosure: public CLDClosure {
-private:
-  PSScavengeFromCLDClosure _oop_closure;
+  PSPromotionManager* _pm;
+
 public:
-  PSScavengeCLDClosure(PSPromotionManager* pm) : _oop_closure(pm) { }
-  void do_cld(ClassLoaderData* cld) {
-    // If the cld has not been dirtied we know that there's
-    // no references into  the young gen and we can skip it.
+  PSScavengeCLDClosure(PSPromotionManager* pm) : _pm(pm) { }
 
-    if (cld->has_modified_oops()) {
-      // Setup the promotion manager to redirty this cld
-      // if references are left in the young gen.
-      _oop_closure.set_scanned_cld(cld);
+  void do_cld(ClassLoaderData* cld) {
+    // If the cld has not been dirtied we know that there are
+    // no references into the young gen, so we can skip it.
+    if (!cld->has_modified_oops()) {
+      return;
+    }
 
-      // Clean the cld since we're going to scavenge all the metadata.
-      cld->oops_do(&_oop_closure, ClassLoaderData::_claim_none, /*clear_modified_oops*/true);
+    PSScavengeCLDOopClosure oop_closure{_pm};
+    // Clean the cld since we're going to scavenge all the metadata.
+    cld->oops_do(&oop_closure, ClassLoaderData::_claim_none, /*clear_modified_oops*/true);
 
-      _oop_closure.set_scanned_cld(nullptr);
+    if (oop_closure._has_oops_into_young_gen) {
+      cld->record_modified_oops();
     }
   }
 };