< prev index next >

src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp

Print this page

  1 /*
  2  * Copyright (c) 2015, 2022, Red Hat, 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 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  *

 25 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
 26 #define SHARE_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
 27 
 28 #include "gc/shared/stringdedup/stringDedup.hpp"
 29 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 31 #include "gc/shenandoah/shenandoahTaskqueue.hpp"
 32 #include "gc/shenandoah/shenandoahUtils.hpp"
 33 #include "memory/iterator.hpp"
 34 #include "runtime/javaThread.hpp"
 35 
 36 enum StringDedupMode {
 37   NO_DEDUP,      // Do not do anything for String deduplication
 38   ENQUEUE_DEDUP, // Enqueue candidate Strings for deduplication, if meet age threshold
 39   ALWAYS_DEDUP   // Enqueue Strings for deduplication
 40 };
 41 
 42 class ShenandoahMarkRefsSuperClosure : public MetadataVisitingOopIterateClosure {
 43 private:
 44   ShenandoahObjToScanQueue* _queue;

 45   ShenandoahMarkingContext* const _mark_context;
 46   bool _weak;
 47 
 48 protected:
 49   template <class T>
 50   void work(T *p);
 51 
 52 public:
 53   ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp);
 54 
 55   bool is_weak() const {
 56     return _weak;
 57   }
 58 
 59   void set_weak(bool weak) {
 60     _weak = weak;
 61   }
 62 
 63   virtual void do_nmethod(nmethod* nm) {
 64     assert(!is_weak(), "Can't handle weak marking of nmethods");
 65     nm->run_nmethod_entry_barrier();
 66   }
 67 };
 68 
 69 class ShenandoahMarkUpdateRefsSuperClosure : public ShenandoahMarkRefsSuperClosure {
 70 protected:
 71   ShenandoahHeap* const _heap;
 72 
 73   template <class T>
 74   inline void work(T* p);
 75 
 76 public:
 77   ShenandoahMarkUpdateRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp) :
 78     ShenandoahMarkRefsSuperClosure(q, rp),
 79     _heap(ShenandoahHeap::heap()) {
 80     assert(_heap->is_stw_gc_in_progress(), "Can only be used for STW GC");
 81   };
 82 };
 83 

 84 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkUpdateRefsSuperClosure {
 85 private:
 86   template <class T>
 87   inline void do_oop_work(T* p)     { work<T>(p); }
 88 
 89 public:
 90   ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp) :
 91     ShenandoahMarkUpdateRefsSuperClosure(q, rp) {}
 92 
 93   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 94   virtual void do_oop(oop* p)       { do_oop_work(p); }
 95 };
 96 

 97 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
 98 private:
 99   template <class T>
100   inline void do_oop_work(T* p)     { work<T>(p); }
101 
102 public:
103   ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp) :
104     ShenandoahMarkRefsSuperClosure(q, rp) {};
105 
106   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
107   virtual void do_oop(oop* p)       { do_oop_work(p); }
108 };
109 
110 
111 class ShenandoahUpdateRefsSuperClosure : public ShenandoahOopClosureBase {
112 protected:
113   ShenandoahHeap* _heap;
114 
115 public:
116   ShenandoahUpdateRefsSuperClosure() :  _heap(ShenandoahHeap::heap()) {}
117 };
118 
119 class ShenandoahSTWUpdateRefsClosure : public ShenandoahUpdateRefsSuperClosure {
120 private:
121   template<class T>
122   inline void work(T* p);
123 
124 public:
125   ShenandoahSTWUpdateRefsClosure() : ShenandoahUpdateRefsSuperClosure() {
126     assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must only be used at safepoints");
127   }
128 
129   virtual void do_oop(narrowOop* p) { work(p); }
130   virtual void do_oop(oop* p)       { work(p); }
131 };
132 
133 class ShenandoahConcUpdateRefsClosure : public ShenandoahUpdateRefsSuperClosure {
134 private:
135   template<class T>
136   inline void work(T* p);
137 
138 public:
139   ShenandoahConcUpdateRefsClosure() : ShenandoahUpdateRefsSuperClosure() {}
140 
141   virtual void do_oop(narrowOop* p) { work(p); }
142   virtual void do_oop(oop* p)       { work(p); }
143 };
144 

















145 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP

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

 26 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
 27 #define SHARE_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
 28 
 29 #include "gc/shared/stringdedup/stringDedup.hpp"
 30 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
 31 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 32 #include "gc/shenandoah/shenandoahTaskqueue.hpp"
 33 #include "gc/shenandoah/shenandoahUtils.hpp"
 34 #include "memory/iterator.hpp"
 35 #include "runtime/javaThread.hpp"
 36 
 37 enum StringDedupMode {
 38   NO_DEDUP,      // Do not do anything for String deduplication
 39   ENQUEUE_DEDUP, // Enqueue candidate Strings for deduplication, if meet age threshold
 40   ALWAYS_DEDUP   // Enqueue Strings for deduplication
 41 };
 42 
 43 class ShenandoahMarkRefsSuperClosure : public MetadataVisitingOopIterateClosure {
 44 private:
 45   ShenandoahObjToScanQueue* _queue;
 46   ShenandoahObjToScanQueue* _old_queue;
 47   ShenandoahMarkingContext* const _mark_context;
 48   bool _weak;
 49 
 50 protected:
 51   template <class T, ShenandoahGenerationType GENERATION>
 52   void work(T *p);
 53 
 54 public:
 55   ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp, ShenandoahObjToScanQueue* old_q);
 56 
 57   bool is_weak() const {
 58     return _weak;
 59   }
 60 
 61   void set_weak(bool weak) {
 62     _weak = weak;
 63   }
 64 
 65   virtual void do_nmethod(nmethod* nm) {
 66     assert(!is_weak(), "Can't handle weak marking of nmethods");
 67     nm->run_nmethod_entry_barrier();
 68   }
 69 };
 70 
 71 class ShenandoahMarkUpdateRefsSuperClosure : public ShenandoahMarkRefsSuperClosure {
 72 protected:
 73   ShenandoahHeap* const _heap;
 74 
 75   template <class T, ShenandoahGenerationType GENERATION>
 76   inline void work(T* p);
 77 
 78 public:
 79   ShenandoahMarkUpdateRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp, ShenandoahObjToScanQueue* old_q) :
 80     ShenandoahMarkRefsSuperClosure(q, rp, old_q),
 81     _heap(ShenandoahHeap::heap()) {
 82     assert(_heap->is_stw_gc_in_progress(), "Can only be used for STW GC");
 83   };
 84 };
 85 
 86 template <ShenandoahGenerationType GENERATION>
 87 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkUpdateRefsSuperClosure {
 88 private:
 89   template <class T>
 90   inline void do_oop_work(T* p)     { work<T, GENERATION>(p); }
 91 
 92 public:
 93   ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp, ShenandoahObjToScanQueue* old_q) :
 94     ShenandoahMarkUpdateRefsSuperClosure(q, rp, old_q) {}
 95 
 96   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 97   virtual void do_oop(oop* p)       { do_oop_work(p); }
 98 };
 99 
100 template <ShenandoahGenerationType GENERATION>
101 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
102 private:
103   template <class T>
104   inline void do_oop_work(T* p)     { work<T, GENERATION>(p); }
105 
106 public:
107   ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp, ShenandoahObjToScanQueue* old_q) :
108     ShenandoahMarkRefsSuperClosure(q, rp, old_q) {};
109 
110   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
111   virtual void do_oop(oop* p)       { do_oop_work(p); }
112 };
113 

114 class ShenandoahUpdateRefsSuperClosure : public ShenandoahOopClosureBase {
115 protected:
116   ShenandoahHeap* _heap;
117 
118 public:
119   ShenandoahUpdateRefsSuperClosure() :  _heap(ShenandoahHeap::heap()) {}
120 };
121 
122 class ShenandoahSTWUpdateRefsClosure : public ShenandoahUpdateRefsSuperClosure {
123 private:
124   template<class T>
125   inline void work(T* p);
126 
127 public:
128   ShenandoahSTWUpdateRefsClosure() : ShenandoahUpdateRefsSuperClosure() {
129     assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must only be used at safepoints");
130   }
131 
132   virtual void do_oop(narrowOop* p) { work(p); }
133   virtual void do_oop(oop* p)       { work(p); }
134 };
135 
136 class ShenandoahConcUpdateRefsClosure : public ShenandoahUpdateRefsSuperClosure {
137 private:
138   template<class T>
139   inline void work(T* p);
140 
141 public:
142   ShenandoahConcUpdateRefsClosure() : ShenandoahUpdateRefsSuperClosure() {}
143 
144   virtual void do_oop(narrowOop* p) { work(p); }
145   virtual void do_oop(oop* p)       { work(p); }
146 };
147 
148 class ShenandoahSetRememberedCardsToDirtyClosure : public BasicOopIterateClosure {
149 protected:
150   ShenandoahHeap*    const _heap;
151   RememberedScanner* const _scanner;
152 
153 public:
154   ShenandoahSetRememberedCardsToDirtyClosure() :
155       _heap(ShenandoahHeap::heap()),
156       _scanner(_heap->card_scan()) {}
157 
158   template<class T>
159   inline void work(T* p);
160 
161   virtual void do_oop(narrowOop* p) { work(p); }
162   virtual void do_oop(oop* p)       { work(p); }
163 };
164 
165 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
< prev index next >