1 /*

     2  * Copyright 2001-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 class HeapRegion;

    26 class G1CollectedHeap;

    27 class G1RemSet;

    28 class HRInto_G1RemSet;

    29 class G1RemSet;

    30 class ConcurrentMark;

    31 class DirtyCardToOopClosure;

    32 class CMBitMap;

    33 class CMMarkStack;

    34 class G1ParScanThreadState;

    35 

    36 // A class that scans oops in a given heap region (much as OopsInGenClosure

    37 // scans oops in a generation.)

    38 class OopsInHeapRegionClosure: public OopsInGenClosure {

    39 protected:

    40   HeapRegion* _from;

    41 public:

    42   virtual void set_region(HeapRegion* from) { _from = from; }

    43 };

    44 

    45 

    46 class G1ScanAndBalanceClosure : public OopClosure {

    47   G1CollectedHeap* _g1;

    48   static int _nq;

    49 public:

    50   G1ScanAndBalanceClosure(G1CollectedHeap* g1) : _g1(g1) { }

    51   inline  void do_oop_nv(oop* p);

    52   inline  void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

    53   virtual void do_oop(oop* p);

    54   virtual void do_oop(narrowOop* p)    { guarantee(false, "NYI"); }

    55 };

    56 

    57 class G1ParClosureSuper : public OopsInHeapRegionClosure {

    58 protected:

    59   G1CollectedHeap* _g1;

    60   G1RemSet* _g1_rem;

    61   ConcurrentMark* _cm;

    62   G1ParScanThreadState* _par_scan_state;

    63 public:

    64   G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);

    65   bool apply_to_weak_ref_discovered_field() { return true; }

    66 };

    67 

    68 class G1ParScanClosure : public G1ParClosureSuper {

    69 public:

    70   G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :

    71     G1ParClosureSuper(g1, par_scan_state) { }

    72   void do_oop_nv(oop* p);   // should be made inline

    73   inline  void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

    74   virtual void do_oop(oop* p)          { do_oop_nv(p); }

    75   virtual void do_oop(narrowOop* p)    { do_oop_nv(p); }

    76 };

    77 

    78 #define G1_PARTIAL_ARRAY_MASK 1

    79 

    80 class G1ParScanPartialArrayClosure : public G1ParClosureSuper {

    81   G1ParScanClosure _scanner;

    82   template <class T> void process_array_chunk(oop obj, int start, int end);

    83 public:

    84   G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :

    85     G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { }

    86   void do_oop_nv(oop* p);

    87   void do_oop_nv(narrowOop* p)      { guarantee(false, "NYI"); }

    88   virtual void do_oop(oop* p)       { do_oop_nv(p); }

    89   virtual void do_oop(narrowOop* p) { do_oop_nv(p); }

    90 };

    91 

    92 

    93 class G1ParCopyHelper : public G1ParClosureSuper {

    94   G1ParScanClosure *_scanner;

    95 protected:

    96   void mark_forwardee(oop* p);

    97   oop copy_to_survivor_space(oop obj);

    98 public:

    99   G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,

   100                   G1ParScanClosure *scanner) :

   101     G1ParClosureSuper(g1, par_scan_state), _scanner(scanner) { }

   102 };

   103 

   104 template<bool do_gen_barrier, G1Barrier barrier, bool do_mark_forwardee>

   105 class G1ParCopyClosure : public G1ParCopyHelper {

   106   G1ParScanClosure _scanner;

   107   void do_oop_work(oop* p);

   108   void do_oop_work(narrowOop* p) { guarantee(false, "NYI"); }

   109 public:

   110   G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :

   111     _scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { }

   112   inline void do_oop_nv(oop* p) {

   113     do_oop_work(p);

   114     if (do_mark_forwardee)

   115       mark_forwardee(p);

   116   }

   117   inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

   118   virtual void do_oop(oop* p)       { do_oop_nv(p); }

   119   virtual void do_oop(narrowOop* p) { do_oop_nv(p); }

   120 };

   121 

   122 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure;

   123 typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure;

   124 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure;

   125 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure;

   126 typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure;

   127 typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure;

   128 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure;

   129 

   130 

   131 class FilterIntoCSClosure: public OopClosure {

   132   G1CollectedHeap* _g1;

   133   OopClosure* _oc;

   134   DirtyCardToOopClosure* _dcto_cl;

   135 public:

   136   FilterIntoCSClosure(  DirtyCardToOopClosure* dcto_cl,

   137                         G1CollectedHeap* g1, OopClosure* oc) :

   138     _dcto_cl(dcto_cl), _g1(g1), _oc(oc)

   139   {}

   140   inline void do_oop_nv(oop* p);

   141   inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

   142   virtual void do_oop(oop* p);

   143   virtual void do_oop(narrowOop* p)   { guarantee(false, "NYI"); }

   144   bool apply_to_weak_ref_discovered_field() { return true; }

   145   bool do_header() { return false; }

   146 };

   147 

   148 class FilterInHeapRegionAndIntoCSClosure : public OopsInHeapRegionClosure {

   149   G1CollectedHeap* _g1;

   150   OopsInHeapRegionClosure* _oc;

   151 public:

   152   FilterInHeapRegionAndIntoCSClosure(G1CollectedHeap* g1,

   153                                      OopsInHeapRegionClosure* oc) :

   154     _g1(g1), _oc(oc)

   155   {}

   156   inline  void do_oop_nv(oop* p);

   157   inline  void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

   158   virtual void do_oop(oop* p);

   159   virtual void do_oop(narrowOop* p)    { guarantee(false, "NYI"); }

   160   bool apply_to_weak_ref_discovered_field() { return true; }

   161   bool do_header() { return false; }

   162   void set_region(HeapRegion* from) {

   163     _oc->set_region(from);

   164   }

   165 };

   166 

   167 class FilterAndMarkInHeapRegionAndIntoCSClosure : public OopsInHeapRegionClosure {

   168   G1CollectedHeap* _g1;

   169   ConcurrentMark* _cm;

   170   OopsInHeapRegionClosure* _oc;

   171 public:

   172   FilterAndMarkInHeapRegionAndIntoCSClosure(G1CollectedHeap* g1,

   173                                             OopsInHeapRegionClosure* oc,

   174                                             ConcurrentMark* cm)

   175   : _g1(g1), _oc(oc), _cm(cm) { }

   176 

   177   inline  void do_oop_nv(oop* p);

   178   inline  void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

   179   virtual void do_oop(oop* p);

   180   virtual void do_oop(narrowOop* p)    { guarantee(false, "NYI"); }

   181   bool apply_to_weak_ref_discovered_field() { return true; }

   182   bool do_header() { return false; }

   183   void set_region(HeapRegion* from) {

   184     _oc->set_region(from);

   185   }

   186 };

   187 

   188 class FilterOutOfRegionClosure: public OopClosure {

   189   HeapWord* _r_bottom;

   190   HeapWord* _r_end;

   191   OopClosure* _oc;

   192   int _out_of_region;

   193 public:

   194   FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc);

   195   inline  void do_oop_nv(oop* p);

   196   inline  void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }

   197   virtual void do_oop(oop* p);

   198   virtual void do_oop(narrowOop* p)   { guarantee(false, "NYI"); }

   199   bool apply_to_weak_ref_discovered_field() { return true; }

   200   bool do_header() { return false; }

   201   int out_of_region() { return _out_of_region; }

   202 };