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

@@ -240,16 +240,16 @@
   DiscoveredList* _discovered_refs;
 
   // Arrays of lists of oops, one per thread (pointers into master array above)
   DiscoveredList* _discoveredSoftRefs;
   DiscoveredList* _discoveredWeakRefs;
+  DiscoveredList* _discoveredEphemerons;
   DiscoveredList* _discoveredFinalRefs;
   DiscoveredList* _discoveredPhantomRefs;
-  DiscoveredList* _discoveredCleanerRefs;
 
  public:
-  static int number_of_subclasses_of_ref() { return (REF_CLEANER - REF_OTHER); }
+  static int number_of_subclasses_of_ref() { return (REF_PHANTOM - REF_OTHER); }
 
   uint num_q()                             { return _num_q; }
   uint max_num_q()                         { return _max_num_q; }
   void set_active_mt_degree(uint v)        { _num_q = v; }
 

@@ -264,10 +264,11 @@
 
   // Process references with a certain reachability level.
   void process_discovered_reflist(DiscoveredList               refs_lists[],
                                   ReferencePolicy*             policy,
                                   bool                         clear_referent,
+                                  bool                         has_ephemerons,
                                   BoolObjectClosure*           is_alive,
                                   OopClosure*                  keep_alive,
                                   VoidClosure*                 complete_gc,
                                   AbstractRefProcTaskExecutor* task_executor);
 

@@ -282,37 +283,60 @@
                       ReferencePolicy*    policy,
                       BoolObjectClosure*  is_alive,
                       OopClosure*         keep_alive,
                       VoidClosure*        complete_gc);
   // Phase2: remove all those references whose referents are
-  // reachable.
-  inline void process_phase2(DiscoveredList&    refs_list,
+  // reachable. Return true if any ephemerons were removed.
+  inline bool process_phase2(DiscoveredList&    refs_list,
+                             bool               has_ephemerons,
                              BoolObjectClosure* is_alive,
                              OopClosure*        keep_alive,
                              VoidClosure*       complete_gc) {
+    if (has_ephemerons) {
+      assert(complete_gc != NULL, "Error");
+      if (discovery_is_atomic()) {
+        return pp2_ephemerons_work(refs_list, is_alive, keep_alive, complete_gc);
+      } else {
+        return pp2_ephemerons_work_concurrent_discovery(refs_list, is_alive,
+                                                        keep_alive, complete_gc);
+      }      
+    } else {
     if (discovery_is_atomic()) {
       // complete_gc is ignored in this case for this phase
       pp2_work(refs_list, is_alive, keep_alive);
     } else {
       assert(complete_gc != NULL, "Error");
       pp2_work_concurrent_discovery(refs_list, is_alive,
                                     keep_alive, complete_gc);
     }
+      return false;
+    }
   }
   // Work methods in support of process_phase2
   void pp2_work(DiscoveredList&    refs_list,
                 BoolObjectClosure* is_alive,
                 OopClosure*        keep_alive);
   void pp2_work_concurrent_discovery(
                 DiscoveredList&    refs_list,
                 BoolObjectClosure* is_alive,
                 OopClosure*        keep_alive,
                 VoidClosure*       complete_gc);
+  bool pp2_ephemerons_work(
+                DiscoveredList&    refs_list,
+                BoolObjectClosure* is_alive,
+                OopClosure*        keep_alive,
+                VoidClosure*       complete_gc);
+  bool pp2_ephemerons_work_concurrent_discovery(
+                DiscoveredList&    refs_list,
+                BoolObjectClosure* is_alive,
+                OopClosure*        keep_alive,
+                VoidClosure*       complete_gc);
   // Phase3: process the referents by either clearing them
   // or keeping them alive (and their closure)
   void process_phase3(DiscoveredList&    refs_list,
                       bool               clear_referent,
+                      bool               has_ephemerons,
                       BoolObjectClosure* is_alive,
                       OopClosure*        keep_alive,
                       VoidClosure*       complete_gc);
 
   // Enqueue references with a certain reachability level

@@ -346,10 +370,18 @@
   void preclean_discovered_reflist(DiscoveredList&    refs_list,
                                    BoolObjectClosure* is_alive,
                                    OopClosure*        keep_alive,
                                    VoidClosure*       complete_gc,
                                    YieldClosure*      yield);
+  // The same as above, but specialized for ephemerons and returns true
+  // if any ephemerons were removed from the list.
+  bool preclean_discovered_ephemerons_reflist(
+                                   DiscoveredList&    refs_list,
+                                   BoolObjectClosure* is_alive,
+                                   OopClosure*        keep_alive,
+                                   VoidClosure*       complete_gc,
+                                   YieldClosure*      yield);
 
   // round-robin mod _num_q (not: _not_ mode _max_num_q)
   uint next_id() {
     uint id = _next_id;
     if (++_next_id == _num_q) {