1 /* 2 * Copyright (c) 2015, Red Hat, Inc. and/or its affiliates. 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/shenandoah/shenandoahTaskqueue.hpp" 28 29 class ShenandoahHeap; 30 class ShenandoahConnectionMatrix; 31 32 enum UpdateRefsMode { 33 NONE, // No reference updating 34 RESOLVE, // Only a read-barrier (no reference updating) 35 SIMPLE, // Reference updating using simple store 36 CONCURRENT // Reference updating using CAS 37 }; 38 39 class ShenandoahMarkRefsSuperClosure : public MetadataAwareOopClosure { 40 private: 41 SCMObjToScanQueue* _queue; 42 ShenandoahHeap* _heap; 43 ShenandoahConnectionMatrix* _conn_matrix; 44 public: 45 ShenandoahMarkRefsSuperClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp); 46 47 template <class T, UpdateRefsMode UPDATE_MODE, bool UPDATE_MATRIX> 48 void work(T *p); 49 }; 50 51 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure { 52 public: 53 ShenandoahMarkUpdateRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 54 ShenandoahMarkRefsSuperClosure(q, rp) {}; 55 56 template <class T> 57 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false>(p); } 58 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 59 virtual void do_oop(oop* p) { do_oop_nv(p); } 60 inline bool do_metadata_nv() { return false; } 61 virtual bool do_metadata() { return false; } 62 }; 63 64 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure { 65 public: 66 ShenandoahMarkUpdateRefsMetadataClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 67 ShenandoahMarkRefsSuperClosure(q, rp) {}; 68 69 template <class T> 70 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false>(p); } 71 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 72 virtual void do_oop(oop* p) { do_oop_nv(p); } 73 inline bool do_metadata_nv() { return true; } 74 virtual bool do_metadata() { return true; } 75 }; 76 77 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure { 78 public: 79 ShenandoahMarkRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 80 ShenandoahMarkRefsSuperClosure(q, rp) {}; 81 82 template <class T> 83 inline void do_oop_nv(T* p) { work<T, NONE, false>(p); } 84 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 85 virtual void do_oop(oop* p) { do_oop_nv(p); } 86 inline bool do_metadata_nv() { return false; } 87 virtual bool do_metadata() { return false; } 88 }; 89 90 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure { 91 public: 92 ShenandoahMarkResolveRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 93 ShenandoahMarkRefsSuperClosure(q, rp) {}; 94 95 template <class T> 96 inline void do_oop_nv(T* p) { work<T, RESOLVE, false>(p); } 97 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 98 virtual void do_oop(oop* p) { do_oop_nv(p); } 99 inline bool do_metadata_nv() { return false; } 100 virtual bool do_metadata() { return false; } 101 }; 102 103 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure { 104 public: 105 ShenandoahMarkRefsMetadataClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 106 ShenandoahMarkRefsSuperClosure(q, rp) {}; 107 108 template <class T> 109 inline void do_oop_nv(T* p) { work<T, NONE, false>(p); } 110 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 111 virtual void do_oop(oop* p) { do_oop_nv(p); } 112 inline bool do_metadata_nv() { return true; } 113 virtual bool do_metadata() { return true; } 114 }; 115 116 class ShenandoahMarkUpdateRefsMatrixClosure : public ShenandoahMarkRefsSuperClosure { 117 public: 118 ShenandoahMarkUpdateRefsMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 119 ShenandoahMarkRefsSuperClosure(q, rp) {}; 120 121 template <class T> 122 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true>(p); } 123 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 124 virtual void do_oop(oop* p) { do_oop_nv(p); } 125 inline bool do_metadata_nv() { return false; } 126 virtual bool do_metadata() { return false; } 127 }; 128 129 class ShenandoahMarkUpdateRefsMetadataMatrixClosure : public ShenandoahMarkRefsSuperClosure { 130 public: 131 ShenandoahMarkUpdateRefsMetadataMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 132 ShenandoahMarkRefsSuperClosure(q, rp) {}; 133 134 template <class T> 135 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true>(p); } 136 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 137 virtual void do_oop(oop* p) { do_oop_nv(p); } 138 inline bool do_metadata_nv() { return true; } 139 virtual bool do_metadata() { return true; } 140 }; 141 142 class ShenandoahMarkRefsMatrixClosure : public ShenandoahMarkRefsSuperClosure { 143 public: 144 ShenandoahMarkRefsMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 145 ShenandoahMarkRefsSuperClosure(q, rp) {}; 146 147 template <class T> 148 inline void do_oop_nv(T* p) { work<T, NONE, true>(p); } 149 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 150 virtual void do_oop(oop* p) { do_oop_nv(p); } 151 inline bool do_metadata_nv() { return false; } 152 virtual bool do_metadata() { return false; } 153 }; 154 155 class ShenandoahMarkRefsMetadataMatrixClosure : public ShenandoahMarkRefsSuperClosure { 156 public: 157 ShenandoahMarkRefsMetadataMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 158 ShenandoahMarkRefsSuperClosure(q, rp) {}; 159 160 template <class T> 161 inline void do_oop_nv(T* p) { work<T, NONE, true>(p); } 162 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 163 virtual void do_oop(oop* p) { do_oop_nv(p); } 164 inline bool do_metadata_nv() { return true; } 165 virtual bool do_metadata() { return true; } 166 }; 167 168 class ShenandoahUpdateHeapRefsSuperClosure : public ExtendedOopClosure { 169 private: 170 ShenandoahHeap* _heap; 171 public: 172 ShenandoahUpdateHeapRefsSuperClosure(); 173 174 template <class T, bool UPDATE_MATRIX> 175 void work(T *p); 176 }; 177 178 class ShenandoahUpdateHeapRefsClosure : public ShenandoahUpdateHeapRefsSuperClosure { 179 public: 180 ShenandoahUpdateHeapRefsClosure() : ShenandoahUpdateHeapRefsSuperClosure() {} 181 182 template <class T> 183 inline void do_oop_nv(T* p) { work<T, false>(p); } 184 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 185 virtual void do_oop(oop* p) { do_oop_nv(p); } 186 }; 187 188 class ShenandoahUpdateHeapRefsMatrixClosure : public ShenandoahUpdateHeapRefsSuperClosure { 189 private: 190 ShenandoahHeap* _heap; 191 public: 192 ShenandoahUpdateHeapRefsMatrixClosure() : ShenandoahUpdateHeapRefsSuperClosure() {} 193 194 template <class T> 195 inline void do_oop_nv(T* p) { work<T, true>(p); } 196 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 197 virtual void do_oop(oop* p) { do_oop_nv(p); } 198 }; 199 200 class PartialEvacuateUpdateHeapClosure : public ExtendedOopClosure { 201 ShenandoahPartialGC* _partial_gc; 202 Thread* _thread; 203 SCMObjToScanQueue* _queue; 204 public: 205 PartialEvacuateUpdateHeapClosure(SCMObjToScanQueue* q) : 206 _partial_gc(ShenandoahHeap::heap()->partial_gc()), 207 _thread(Thread::current()), _queue(q) {} 208 209 template <class T> 210 void do_oop_nv(T* p); 211 212 void do_oop(oop* p) { do_oop_nv(p); } 213 void do_oop(narrowOop* p) { do_oop_nv(p); } 214 }; 215 216 217 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP