rev 2691 : [mq]: g1-reference-processing

          --- old/src/share/vm/gc_implementation/g1/g1OopClosures.hpp
          +++ new/src/share/vm/gc_implementation/g1/g1OopClosures.hpp

   1    1  /*
   2    2   * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
  13   13   * accompanied this code).
  14   14   *
  15   15   * You should have received a copy of the GNU General Public License version
  16   16   * 2 along with this work; if not, write to the Free Software Foundation,
  17   17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18   18   *
  19   19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20   20   * or visit www.oracle.com if you need additional information or have any
  21   21   * questions.
  22   22   *
  23   23   */
  24   24  
  25   25  #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
  26   26  #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP

  27   27  
  28   28  class HeapRegion;
  29   29  class G1CollectedHeap;
  30   30  class G1RemSet;
  31   31  class ConcurrentMark;
  32   32  class DirtyCardToOopClosure;
  33   33  class CMBitMap;
  34   34  class CMMarkStack;
  35   35  class G1ParScanThreadState;
  36   36  class CMTask;
       37 +class ReferenceProcessor;
  37   38  
  38   39  // A class that scans oops in a given heap region (much as OopsInGenClosure
  39   40  // scans oops in a generation.)
  40   41  class OopsInHeapRegionClosure: public OopsInGenClosure {
  41   42  protected:
  42   43    HeapRegion* _from;
  43   44  public:
  44   45    void set_region(HeapRegion* from) { _from = from; }
  45   46  };
  46   47  

  47   48  class G1ParClosureSuper : public OopsInHeapRegionClosure {
  48   49  protected:
  49   50    G1CollectedHeap* _g1;
  50   51    G1RemSet* _g1_rem;
  51   52    ConcurrentMark* _cm;

  52   53    G1ParScanThreadState* _par_scan_state;
  53   54    bool _during_initial_mark;
  54   55    bool _mark_in_progress;
  55   56  public:
  56   57    G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
  57   58    bool apply_to_weak_ref_discovered_field() { return true; }
  58   59  };
  59   60  
  60   61  class G1ParPushHeapRSClosure : public G1ParClosureSuper {
  61   62  public:
  62      -  G1ParPushHeapRSClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
  63      -    G1ParClosureSuper(g1, par_scan_state) { }
       63 +  G1ParPushHeapRSClosure(G1CollectedHeap* g1,
       64 +                         G1ParScanThreadState* par_scan_state,
       65 +                         ReferenceProcessor* rp) :
       66 +    G1ParClosureSuper(g1, par_scan_state)
       67 +  {
       68 +    assert(_ref_processor == NULL, "sanity");
       69 +    _ref_processor = rp;
       70 +  }
       71 +
  64   72    template <class T> void do_oop_nv(T* p);
  65   73    virtual void do_oop(oop* p)          { do_oop_nv(p); }
  66   74    virtual void do_oop(narrowOop* p)    { do_oop_nv(p); }
  67   75  };
  68   76  
  69   77  class G1ParScanClosure : public G1ParClosureSuper {
  70   78  public:
  71      -  G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
  72      -    G1ParClosureSuper(g1, par_scan_state) { }
       79 +  G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
       80 +    G1ParClosureSuper(g1, par_scan_state)
       81 +  {
       82 +    assert(_ref_processor == NULL, "sanity");
       83 +    _ref_processor = rp;
       84 +  }
       85 +
  73   86    template <class T> void do_oop_nv(T* p);
  74   87    virtual void do_oop(oop* p)          { do_oop_nv(p); }
  75   88    virtual void do_oop(narrowOop* p)    { do_oop_nv(p); }
  76   89  };
  77   90  
  78   91  #define G1_PARTIAL_ARRAY_MASK 0x2
  79   92  
  80   93  template <class T> inline bool has_partial_array_mask(T* ref) {
  81   94    return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK;
  82   95  }

  83   96  
  84   97  template <class T> inline T* set_partial_array_mask(T obj) {

  85   98    assert(((uintptr_t)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!");
  86   99    return (T*) ((uintptr_t)obj | G1_PARTIAL_ARRAY_MASK);
  87  100  }
  88  101  
  89  102  template <class T> inline oop clear_partial_array_mask(T* ref) {
  90  103    return oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK);
  91  104  }
  92  105  
  93  106  class G1ParScanPartialArrayClosure : public G1ParClosureSuper {
  94  107    G1ParScanClosure _scanner;
      108 +
  95  109  public:
  96      -  G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
  97      -    G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { }
      110 +  G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
      111 +    G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state, rp)
      112 +  {
      113 +    assert(_ref_processor == NULL, "sanity");
      114 +  }
      115 +
      116 +  G1ParScanClosure* scanner() {
      117 +    return &_scanner;
      118 +  }
      119 +
  98  120    template <class T> void do_oop_nv(T* p);
  99  121    virtual void do_oop(oop* p)       { do_oop_nv(p); }
 100  122    virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 101  123  };
 102  124  
 103  125  
 104  126  class G1ParCopyHelper : public G1ParClosureSuper {
 105  127    G1ParScanClosure *_scanner;
 106  128  protected:
 107  129    template <class T> void mark_object(T* p);

 108  130    oop copy_to_survivor_space(oop obj, bool should_mark_copy);

 109  131  public:
 110  132    G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
 111  133                    G1ParScanClosure *scanner) :
 112  134      G1ParClosureSuper(g1, par_scan_state), _scanner(scanner) { }
 113  135  };
 114  136  
 115  137  template<bool do_gen_barrier, G1Barrier barrier,
 116  138           bool do_mark_object>
 117  139  class G1ParCopyClosure : public G1ParCopyHelper {
 118  140    G1ParScanClosure _scanner;
      141 +
 119  142    template <class T> void do_oop_work(T* p);
      143 +
 120  144  public:
 121      -  G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
 122      -    _scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { }
      145 +  G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
      146 +                   ReferenceProcessor* rp) :
      147 +    _scanner(g1, par_scan_state, rp),
      148 +    G1ParCopyHelper(g1, par_scan_state, &_scanner)
      149 +  {
      150 +    assert(_ref_processor == NULL, "sanity");
      151 +  }
      152 +
      153 +  G1ParScanClosure* scanner() { return &_scanner; }
      154 +
 123  155    template <class T> void do_oop_nv(T* p) {
 124  156      do_oop_work(p);
 125  157    }
 126  158    virtual void do_oop(oop* p)       { do_oop_nv(p); }
 127  159    virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 128  160  };
 129  161  
 130  162  typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure;
 131  163  typedef G1ParCopyClosure<true,  G1BarrierNone, false> G1ParScanPermClosure;
 132      -typedef G1ParCopyClosure<false, G1BarrierRS,   false> G1ParScanHeapRSClosure;
      164 +
 133  165  typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure;
 134  166  typedef G1ParCopyClosure<true,  G1BarrierNone, true> G1ParScanAndMarkPermClosure;
 135      -typedef G1ParCopyClosure<false, G1BarrierRS,   true> G1ParScanAndMarkHeapRSClosure;
 136  167  
 137      -// This is the only case when we set skip_cset_test. Basically, this
 138      -// closure is (should?) only be called directly while we're draining
 139      -// the overflow and task queues. In that case we know that the
 140      -// reference in question points into the collection set, otherwise we
 141      -// would not have pushed it on the queue. The following is defined in
 142      -// g1_specialized_oop_closures.hpp.
 143      -// typedef G1ParCopyClosure<false, G1BarrierEvac, false, true> G1ParScanHeapEvacClosure;
 144      -// We need a separate closure to handle references during evacuation
 145      -// failure processing, as we cannot asume that the reference already
 146      -// points into the collection set (like G1ParScanHeapEvacClosure does).
      168 +// The following closure types are no longer used but are retained
      169 +// for historical reasons:
      170 +// typedef G1ParCopyClosure<false, G1BarrierRS,   false> G1ParScanHeapRSClosure;
      171 +// typedef G1ParCopyClosure<false, G1BarrierRS,   true> G1ParScanAndMarkHeapRSClosure;
      172 +
      173 +// The following closure type is defined in g1_specialized_oop_closures.hpp:
      174 +//
      175 +// typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure;
      176 +
      177 +// We use a separate closure to handle references during evacuation
      178 +// failure processing.
      179 +// We could have used another instance of G1ParScanHeapEvacClosure
      180 +// (since that closure no longer assumes that the references it
      181 +// handles point into the collection set).
      182 +
 147  183  typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure;
 148  184  
 149  185  class FilterIntoCSClosure: public OopClosure {
 150  186    G1CollectedHeap* _g1;
 151  187    OopClosure* _oc;
 152  188    DirtyCardToOopClosure* _dcto_cl;
 153  189  public:
 154  190    FilterIntoCSClosure(  DirtyCardToOopClosure* dcto_cl,
 155      -                        G1CollectedHeap* g1, OopClosure* oc) :
      191 +                        G1CollectedHeap* g1,
      192 +                        OopClosure* oc,
      193 +                        ReferenceProcessor* rp) :
 156  194      _dcto_cl(dcto_cl), _g1(g1), _oc(oc)
 157      -  {}
      195 +  {
      196 +    assert(_ref_processor == NULL, "sanity");
      197 +    _ref_processor = rp;
      198 +  }
      199 +
 158  200    template <class T> void do_oop_nv(T* p);
 159  201    virtual void do_oop(oop* p)        { do_oop_nv(p); }
 160  202    virtual void do_oop(narrowOop* p)  { do_oop_nv(p); }
 161  203    bool apply_to_weak_ref_discovered_field() { return true; }
 162  204    bool do_header() { return false; }
 163  205  };
 164  206  
 165  207  class FilterOutOfRegionClosure: public OopClosure {
 166  208    HeapWord* _r_bottom;
 167  209    HeapWord* _r_end;

 168  210    OopClosure* _oc;
 169  211    int _out_of_region;
 170  212  public:
 171  213    FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc);
 172  214    template <class T> void do_oop_nv(T* p);
 173  215    virtual void do_oop(oop* p) { do_oop_nv(p); }
 174  216    virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 175  217    bool apply_to_weak_ref_discovered_field() { return true; }
 176  218    bool do_header() { return false; }
 177  219    int out_of_region() { return _out_of_region; }
 178  220  };
 179  221  
 180  222  // Closure for iterating over object fields during concurrent marking
 181  223  class G1CMOopClosure : public OopClosure {
 182  224    G1CollectedHeap*   _g1h;
 183  225    ConcurrentMark*    _cm;
 184  226    CMTask*            _task;
 185  227  public:
 186  228    G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task);
 187  229    template <class T> void do_oop_nv(T* p);
 188  230    virtual void do_oop(      oop* p) { do_oop_nv(p); }
 189  231    virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
 190  232  };
 191  233  
 192  234  #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX