1 /*

     2  * Copyright (c) 2015, 2018, Red Hat, Inc. All rights reserved.

     3  *

     4  * This code is free software; you can redistribute it and/or modify it

     5  * under the terms of the GNU General Public License version 2 only, as

     6  * published by the Free Software Foundation.

     7  *

     8  * This code is distributed in the hope that it will be useful, but WITHOUT

     9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    11  * version 2 for more details (a copy is included in the LICENSE file that

    12  * accompanied this code).

    13  *

    14  * You should have received a copy of the GNU General Public License version

    15  * 2 along with this work; if not, write to the Free Software Foundation,

    16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    17  *

    18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    19  * or visit www.oracle.com if you need additional information or have any

    20  * questions.

    21  *

    22  */

    23 

    24 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP

    25 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP

    26 

    27 #include "gc/shared/referenceProcessor.hpp"

    28 #include "gc/shenandoah/shenandoahHeap.hpp"

    29 #include "gc/shenandoah/shenandoahStrDedupQueue.hpp"

    30 #include "gc/shenandoah/shenandoahTaskqueue.hpp"

    31 #include "gc/shenandoah/shenandoahTraversalGC.hpp"

    32 #include "memory/iterator.hpp"

    33 #include "runtime/thread.hpp"

    34 

    35 enum UpdateRefsMode {

    36   NONE,       // No reference updating

    37   RESOLVE,    // Only a read-barrier (no reference updating)

    38   SIMPLE,     // Reference updating using simple store

    39   CONCURRENT  // Reference updating using CAS

    40 };

    41 

    42 enum StringDedupMode {

    43   NO_DEDUP,      // Do not do anything for String deduplication

    44   ENQUEUE_DEDUP, // Enqueue candidate Strings for deduplication

    45 };

    46 

    47 class ShenandoahMarkRefsSuperClosure : public MetadataVisitingOopIterateClosure {

    48 private:

    49   ShenandoahObjToScanQueue* _queue;

    50   ShenandoahHeap* _heap;

    51   ShenandoahMarkingContext* const _mark_context;

    52 

    53 protected:

    54   template <class T, UpdateRefsMode UPDATE_MODE, StringDedupMode STRING_DEDUP>

    55   void work(T *p);

    56 

    57 public:

    58   ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp);

    59 };

    60 

    61 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure {

    62 private:

    63   template <class T>

    64   inline void do_oop_work(T* p)     { work<T, CONCURRENT, NO_DEDUP>(p); }

    65 

    66 public:

    67   ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

    68           ShenandoahMarkRefsSuperClosure(q, rp) {};

    69 

    70   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

    71   virtual void do_oop(oop* p)       { do_oop_work(p); }

    72   virtual bool do_metadata()        { return false; }

    73 };

    74 

    75 class ShenandoahMarkUpdateRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {

    76 private:

    77   template <class T>

    78   inline void do_oop_work(T* p)     { work<T, CONCURRENT, ENQUEUE_DEDUP>(p); }

    79 

    80 public:

    81   ShenandoahMarkUpdateRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

    82           ShenandoahMarkRefsSuperClosure(q, rp) {};

    83 

    84   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

    85   virtual void do_oop(oop* p)       { do_oop_work(p); }

    86   virtual bool do_metadata()        { return false; }

    87 };

    88 

    89 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {

    90 private:

    91   template <class T>

    92   inline void do_oop_work(T* p)     { work<T, CONCURRENT, NO_DEDUP>(p); }

    93 

    94 public:

    95   ShenandoahMarkUpdateRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

    96     ShenandoahMarkRefsSuperClosure(q, rp) {};

    97 

    98   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

    99   virtual void do_oop(oop* p)       { do_oop_work(p); }

   100   virtual bool do_metadata()        { return true; }

   101 };

   102 

   103 class ShenandoahMarkUpdateRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {

   104 private:

   105   template <class T>

   106   inline void do_oop_work(T* p)     { work<T, CONCURRENT, ENQUEUE_DEDUP>(p); }

   107 

   108 public:

   109   ShenandoahMarkUpdateRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   110   ShenandoahMarkRefsSuperClosure(q, rp) {};

   111 

   112   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   113   virtual void do_oop(oop* p)       { do_oop_work(p); }

   114   virtual bool do_metadata()        { return true; }

   115 };

   116 

   117 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {

   118 private:

   119   template <class T>

   120   inline void do_oop_work(T* p)     { work<T, NONE, NO_DEDUP>(p); }

   121 

   122 public:

   123   ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   124     ShenandoahMarkRefsSuperClosure(q, rp) {};

   125 

   126   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   127   virtual void do_oop(oop* p)       { do_oop_work(p); }

   128   virtual bool do_metadata()        { return false; }

   129 };

   130 

   131 class ShenandoahMarkRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {

   132 private:

   133   template <class T>

   134   inline void do_oop_work(T* p)     { work<T, NONE, ENQUEUE_DEDUP>(p); }

   135 

   136 public:

   137   ShenandoahMarkRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   138     ShenandoahMarkRefsSuperClosure(q, rp) {};

   139 

   140   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   141   virtual void do_oop(oop* p)       { do_oop_work(p); }

   142   virtual bool do_metadata()        { return false; }

   143 };

   144 

   145 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure {

   146 private:

   147   template <class T>

   148   inline void do_oop_work(T* p)     { work<T, RESOLVE, NO_DEDUP>(p); }

   149 

   150 public:

   151   ShenandoahMarkResolveRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   152     ShenandoahMarkRefsSuperClosure(q, rp) {};

   153 

   154   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   155   virtual void do_oop(oop* p)       { do_oop_work(p); }

   156   virtual bool do_metadata()        { return false; }

   157 };

   158 

   159 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {

   160 private:

   161   template <class T>

   162   inline void do_oop_work(T* p)     { work<T, NONE, NO_DEDUP>(p); }

   163 

   164 public:

   165   ShenandoahMarkRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   166     ShenandoahMarkRefsSuperClosure(q, rp) {};

   167 

   168   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   169   virtual void do_oop(oop* p)       { do_oop_work(p); }

   170   virtual bool do_metadata()        { return true; }

   171 };

   172 

   173 class ShenandoahMarkRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {

   174 private:

   175   template <class T>

   176   inline void do_oop_work(T* p)     { work<T, NONE, ENQUEUE_DEDUP>(p); }

   177 

   178 public:

   179   ShenandoahMarkRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   180     ShenandoahMarkRefsSuperClosure(q, rp) {};

   181 

   182   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   183   virtual void do_oop(oop* p)       { do_oop_work(p); }

   184   virtual bool do_metadata()        { return true; }

   185 };

   186 

   187 class ShenandoahUpdateHeapRefsSuperClosure : public BasicOopIterateClosure {

   188 private:

   189   ShenandoahHeap* _heap;

   190 public:

   191   ShenandoahUpdateHeapRefsSuperClosure() :

   192     _heap(ShenandoahHeap::heap()) {}

   193 

   194   template <class T>

   195   void work(T *p);

   196 };

   197 

   198 class ShenandoahUpdateHeapRefsClosure : public ShenandoahUpdateHeapRefsSuperClosure {

   199 private:

   200   template <class T>

   201   inline  void do_oop_work(T* p)    { work<T>(p); }

   202 

   203 public:

   204   ShenandoahUpdateHeapRefsClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}

   205 

   206   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   207   virtual void do_oop(oop* p)       { do_oop_work(p); }

   208 };

   209 

   210 class ShenandoahTraversalSuperClosure : public MetadataVisitingOopIterateClosure {

   211 private:

   212   ShenandoahTraversalGC* const _traversal_gc;

   213   Thread* const _thread;

   214   ShenandoahObjToScanQueue* const _queue;

   215   ShenandoahMarkingContext* const _mark_context;

   216 protected:

   217   ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   218     MetadataVisitingOopIterateClosure(rp),

   219     _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),

   220     _thread(Thread::current()),

   221     _queue(q),

   222     _mark_context(ShenandoahHeap::heap()->marking_context()) {

   223   }

   224 

   225   template <class T, bool STRING_DEDUP, bool DEGEN>

   226   void work(T* p);

   227 

   228 };

   229 

   230 class ShenandoahTraversalClosure : public ShenandoahTraversalSuperClosure {

   231 private:

   232   template <class T>

   233   inline void do_oop_work(T* p)     { work<T, false, false>(p); }

   234 

   235 public:

   236   ShenandoahTraversalClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   237     ShenandoahTraversalSuperClosure(q, rp) {}

   238 

   239   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   240   virtual void do_oop(oop* p)       { do_oop_work(p); }

   241 

   242   virtual bool do_metadata()        { return false; }

   243 };

   244 

   245 class ShenandoahTraversalMetadataClosure : public ShenandoahTraversalSuperClosure {

   246 private:

   247   template <class T>

   248   inline void do_oop_work(T* p)     { work<T, false, false>(p); }

   249 

   250 public:

   251   ShenandoahTraversalMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   252     ShenandoahTraversalSuperClosure(q, rp) {}

   253 

   254   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   255   virtual void do_oop(oop* p)       { do_oop_work(p); }

   256 

   257   virtual bool do_metadata()        { return true; }

   258 };

   259 

   260 class ShenandoahTraversalDedupClosure : public ShenandoahTraversalSuperClosure {

   261 private:

   262   template <class T>

   263   inline void do_oop_work(T* p)     { work<T, true, false>(p); }

   264 

   265 public:

   266   ShenandoahTraversalDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   267     ShenandoahTraversalSuperClosure(q, rp) {}

   268 

   269   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   270   virtual void do_oop(oop* p)       { do_oop_work(p); }

   271 

   272   virtual bool do_metadata()        { return false; }

   273 };

   274 

   275 class ShenandoahTraversalMetadataDedupClosure : public ShenandoahTraversalSuperClosure {

   276 private:

   277   template <class T>

   278   inline void do_oop_work(T* p)     { work<T, true, false>(p); }

   279 

   280 public:

   281   ShenandoahTraversalMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   282     ShenandoahTraversalSuperClosure(q, rp) {}

   283 

   284   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   285   virtual void do_oop(oop* p)       { do_oop_work(p); }

   286 

   287   virtual bool do_metadata()        { return true; }

   288 };

   289 

   290 class ShenandoahTraversalDegenClosure : public ShenandoahTraversalSuperClosure {

   291 private:

   292   template <class T>

   293   inline void do_oop_work(T* p)     { work<T, false, true>(p); }

   294 

   295 public:

   296   ShenandoahTraversalDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   297     ShenandoahTraversalSuperClosure(q, rp) {}

   298 

   299   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   300   virtual void do_oop(oop* p)       { do_oop_work(p); }

   301 

   302   virtual bool do_metadata()        { return false; }

   303 };

   304 

   305 class ShenandoahTraversalMetadataDegenClosure : public ShenandoahTraversalSuperClosure {

   306 private:

   307   template <class T>

   308   inline void do_oop_work(T* p)     { work<T, false, true>(p); }

   309 

   310 public:

   311   ShenandoahTraversalMetadataDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   312     ShenandoahTraversalSuperClosure(q, rp) {}

   313 

   314   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   315   virtual void do_oop(oop* p)       { do_oop_work(p); }

   316 

   317   virtual bool do_metadata()        { return true; }

   318 };

   319 

   320 class ShenandoahTraversalDedupDegenClosure : public ShenandoahTraversalSuperClosure {

   321 private:

   322   template <class T>

   323   inline void do_oop_work(T* p)     { work<T, true, true>(p); }

   324 

   325 public:

   326   ShenandoahTraversalDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   327     ShenandoahTraversalSuperClosure(q, rp) {}

   328 

   329   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   330   virtual void do_oop(oop* p)       { do_oop_work(p); }

   331 

   332   virtual bool do_metadata()        { return false; }

   333 };

   334 

   335 class ShenandoahTraversalMetadataDedupDegenClosure : public ShenandoahTraversalSuperClosure {

   336 private:

   337   template <class T>

   338   inline void do_oop_work(T* p)     { work<T, true, true>(p); }

   339 

   340 public:

   341   ShenandoahTraversalMetadataDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :

   342     ShenandoahTraversalSuperClosure(q, rp) {}

   343 

   344   virtual void do_oop(narrowOop* p) { do_oop_work(p); }

   345   virtual void do_oop(oop* p)       { do_oop_work(p); }

   346 

   347   virtual bool do_metadata()        { return true; }

   348 };

   349 

   350 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP