1 /*
   2  * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_G1_G1OOPCLOSURES_HPP
  26 #define SHARE_VM_GC_G1_G1OOPCLOSURES_HPP
  27 
  28 #include "memory/iterator.hpp"
  29 #include "oops/markOop.hpp"
  30 
  31 class HeapRegion;
  32 class G1CollectedHeap;
  33 class G1RemSet;
  34 class ConcurrentMark;
  35 class DirtyCardToOopClosure;
  36 class CMBitMap;
  37 class CMMarkStack;
  38 class G1ParScanThreadState;
  39 class CMTask;
  40 class ReferenceProcessor;
  41 
  42 // A class that scans oops in a given heap region (much as OopsInGenClosure
  43 // scans oops in a generation.)
  44 class OopsInHeapRegionClosure: public ExtendedOopClosure {
  45 protected:
  46   HeapRegion* _from;
  47 public:
  48   void set_region(HeapRegion* from) { _from = from; }
  49 };
  50 
  51 class G1ParClosureSuper : public OopsInHeapRegionClosure {
  52 protected:
  53   G1CollectedHeap* _g1;
  54   G1ParScanThreadState* _par_scan_state;
  55 
  56   G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
  57   ~G1ParClosureSuper() { }
  58 
  59 public:
  60   virtual bool apply_to_weak_ref_discovered_field() { return true; }
  61 };
  62 
  63 class G1ParPushHeapRSClosure : public G1ParClosureSuper {
  64 public:
  65   G1ParPushHeapRSClosure(G1CollectedHeap* g1,
  66                          G1ParScanThreadState* par_scan_state):
  67     G1ParClosureSuper(g1, par_scan_state) { }
  68 
  69   template <class T> void do_oop_nv(T* p);
  70   virtual void do_oop(oop* p)          { do_oop_nv(p); }
  71   virtual void do_oop(narrowOop* p)    { do_oop_nv(p); }
  72 };
  73 
  74 class G1ParScanClosure : public G1ParClosureSuper {
  75 public:
  76   G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
  77     G1ParClosureSuper(g1, par_scan_state) { }
  78 
  79   template <class T> void do_oop_nv(T* p);
  80   virtual void do_oop(oop* p)          { do_oop_nv(p); }
  81   virtual void do_oop(narrowOop* p)    { do_oop_nv(p); }
  82 
  83   void set_ref_processor(ReferenceProcessor* rp) {
  84     set_ref_processor_internal(rp);
  85   }
  86 };
  87 
  88 // Add back base class for metadata
  89 class G1ParCopyHelper : public OopClosure {
  90 protected:
  91   G1CollectedHeap* _g1;
  92   G1ParScanThreadState* _par_scan_state;
  93   uint _worker_id;              // Cache value from par_scan_state.
  94   Klass* _scanned_klass;
  95   ConcurrentMark* _cm;
  96 
  97   // Mark the object if it's not already marked. This is used to mark
  98   // objects pointed to by roots that are guaranteed not to move
  99   // during the GC (i.e., non-CSet objects). It is MT-safe.
 100   inline void mark_object(oop obj);
 101 
 102   // Mark the object if it's not already marked. This is used to mark
 103   // objects pointed to by roots that have been forwarded during a
 104   // GC. It is MT-safe.
 105   inline void mark_forwarded_object(oop from_obj, oop to_obj);
 106 
 107   G1ParCopyHelper(G1CollectedHeap* g1,  G1ParScanThreadState* par_scan_state);
 108   ~G1ParCopyHelper() { }
 109 
 110  public:
 111   void set_scanned_klass(Klass* k) { _scanned_klass = k; }
 112   template <class T> inline void do_klass_barrier(T* p, oop new_obj);
 113 };
 114 
 115 enum G1Barrier {
 116   G1BarrierNone,
 117   G1BarrierKlass
 118 };
 119 
 120 enum G1Mark {
 121   G1MarkNone,
 122   G1MarkFromRoot,
 123   G1MarkPromotedFromRoot
 124 };
 125 
 126 template <G1Barrier barrier, G1Mark do_mark_object, bool use_ext>
 127 class G1ParCopyClosure : public G1ParCopyHelper {
 128 public:
 129   G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
 130       G1ParCopyHelper(g1, par_scan_state) { }
 131 
 132   template <class T> void do_oop_work(T* p);
 133   virtual void do_oop(oop* p)       { do_oop_work(p); }
 134   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 135 };
 136 
 137 class G1KlassScanClosure : public KlassClosure {
 138  G1ParCopyHelper* _closure;
 139  bool             _process_only_dirty;
 140  int              _count;
 141  public:
 142   G1KlassScanClosure(G1ParCopyHelper* closure, bool process_only_dirty)
 143       : _process_only_dirty(process_only_dirty), _closure(closure), _count(0) {}
 144   void do_klass(Klass* klass);
 145 };
 146 
 147 class FilterIntoCSClosure: public OopClosure {
 148   G1CollectedHeap* _g1;
 149   OopClosure* _oc;
 150 public:
 151   FilterIntoCSClosure(G1CollectedHeap* g1, OopClosure* oc) : _g1(g1), _oc(oc) { }
 152 
 153   template <class T> void do_oop_work(T* p);
 154   virtual void do_oop(oop* p)        { do_oop_work(p); }
 155   virtual void do_oop(narrowOop* p)  { do_oop_work(p); }
 156 };
 157 
 158 class FilterOutOfRegionClosure: public ExtendedOopClosure {
 159   HeapWord* _r_bottom;
 160   HeapWord* _r_end;
 161   OopClosure* _oc;
 162 public:
 163   FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc);
 164   template <class T> void do_oop_nv(T* p);
 165   virtual void do_oop(oop* p) { do_oop_nv(p); }
 166   virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 167   bool apply_to_weak_ref_discovered_field() { return true; }
 168 };
 169 
 170 // Closure for iterating over object fields during concurrent marking
 171 class G1CMOopClosure : public MetadataAwareOopClosure {
 172 protected:
 173   ConcurrentMark*    _cm;
 174 private:
 175   G1CollectedHeap*   _g1h;
 176   CMTask*            _task;
 177 public:
 178   G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task);
 179   template <class T> void do_oop_nv(T* p);
 180   virtual void do_oop(      oop* p) { do_oop_nv(p); }
 181   virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 182 };
 183 
 184 // Closure to scan the root regions during concurrent marking
 185 class G1RootRegionScanClosure : public MetadataAwareOopClosure {
 186 private:
 187   G1CollectedHeap* _g1h;
 188   ConcurrentMark*  _cm;
 189   uint _worker_id;
 190 public:
 191   G1RootRegionScanClosure(G1CollectedHeap* g1h, ConcurrentMark* cm,
 192                           uint worker_id) :
 193     _g1h(g1h), _cm(cm), _worker_id(worker_id) { }
 194   template <class T> void do_oop_nv(T* p);
 195   virtual void do_oop(      oop* p) { do_oop_nv(p); }
 196   virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 197 };
 198 
 199 // Closure that applies the given two closures in sequence.
 200 // Used by the RSet refinement code (when updating RSets
 201 // during an evacuation pause) to record cards containing
 202 // pointers into the collection set.
 203 
 204 class G1Mux2Closure : public OopClosure {
 205   OopClosure* _c1;
 206   OopClosure* _c2;
 207 public:
 208   G1Mux2Closure(OopClosure *c1, OopClosure *c2);
 209   template <class T> inline void do_oop_work(T* p);
 210   virtual inline void do_oop(oop* p);
 211   virtual inline void do_oop(narrowOop* p);
 212 };
 213 
 214 // A closure that returns true if it is actually applied
 215 // to a reference
 216 
 217 class G1TriggerClosure : public OopClosure {
 218   bool _triggered;
 219 public:
 220   G1TriggerClosure();
 221   bool triggered() const { return _triggered; }
 222   template <class T> inline void do_oop_work(T* p);
 223   virtual inline void do_oop(oop* p);
 224   virtual inline void do_oop(narrowOop* p);
 225 };
 226 
 227 // A closure which uses a triggering closure to determine
 228 // whether to apply an oop closure.
 229 
 230 class G1InvokeIfNotTriggeredClosure: public OopClosure {
 231   G1TriggerClosure* _trigger_cl;
 232   OopClosure* _oop_cl;
 233 public:
 234   G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t, OopClosure* oc);
 235   template <class T> inline void do_oop_work(T* p);
 236   virtual inline void do_oop(oop* p);
 237   virtual inline void do_oop(narrowOop* p);
 238 };
 239 
 240 class G1UpdateRSOrPushRefOopClosure: public OopClosure {
 241   G1CollectedHeap* _g1;
 242   G1RemSet* _g1_rem_set;
 243   HeapRegion* _from;
 244   G1ParPushHeapRSClosure* _push_ref_cl;
 245   bool _record_refs_into_cset;
 246   uint _worker_i;
 247 
 248 public:
 249   G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h,
 250                                 G1RemSet* rs,
 251                                 G1ParPushHeapRSClosure* push_ref_cl,
 252                                 bool record_refs_into_cset,
 253                                 uint worker_i = 0);
 254 
 255   void set_from(HeapRegion* from) {
 256     assert(from != NULL, "from region must be non-NULL");
 257     _from = from;
 258   }
 259 
 260   bool self_forwarded(oop obj) {
 261     markOop m = obj->mark();
 262     bool result = (m->is_marked() && ((oop)m->decode_pointer() == obj));
 263     return result;
 264   }
 265 
 266   template <class T> inline void do_oop_work(T* p);
 267   virtual inline void do_oop(narrowOop* p);
 268   virtual inline void do_oop(oop* p);
 269 };
 270 
 271 #endif // SHARE_VM_GC_G1_G1OOPCLOSURES_HPP