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 typedef BufferedOverflowTaskQueue<ObjArrayChunkedTask, mtGC> ShenandoahBufferedOverflowTaskQueue; 30 typedef Padded<ShenandoahBufferedOverflowTaskQueue> SCMObjToScanQueue; 31 32 class ShenandoahHeap; 33 class ShenandoahConnectionMatrix; 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 class ShenandoahMarkRefsSuperClosure : public MetadataAwareOopClosure { 43 private: 44 SCMObjToScanQueue* _queue; 45 ShenandoahHeap* _heap; 46 ShenandoahConnectionMatrix* _conn_matrix; 47 public: 48 ShenandoahMarkRefsSuperClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp); 49 50 template <class T, UpdateRefsMode UPDATE_MODE, bool UPDATE_MATRIX> 51 void work(T *p); 52 }; 53 54 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure { 55 public: 56 ShenandoahMarkUpdateRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 57 ShenandoahMarkRefsSuperClosure(q, rp) {}; 58 59 template <class T> 60 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false>(p); } 61 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 62 virtual void do_oop(oop* p) { do_oop_nv(p); } 63 inline bool do_metadata_nv() { return false; } 64 virtual bool do_metadata() { return false; } 65 }; 66 67 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure { 68 public: 69 ShenandoahMarkUpdateRefsMetadataClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 70 ShenandoahMarkRefsSuperClosure(q, rp) {}; 71 72 template <class T> 73 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false>(p); } 74 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 75 virtual void do_oop(oop* p) { do_oop_nv(p); } 76 inline bool do_metadata_nv() { return true; } 77 virtual bool do_metadata() { return true; } 78 }; 79 80 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure { 81 public: 82 ShenandoahMarkRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 83 ShenandoahMarkRefsSuperClosure(q, rp) {}; 84 85 template <class T> 86 inline void do_oop_nv(T* p) { work<T, NONE, false>(p); } 87 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 88 virtual void do_oop(oop* p) { do_oop_nv(p); } 89 inline bool do_metadata_nv() { return false; } 90 virtual bool do_metadata() { return false; } 91 }; 92 93 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure { 94 public: 95 ShenandoahMarkResolveRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 96 ShenandoahMarkRefsSuperClosure(q, rp) {}; 97 98 template <class T> 99 inline void do_oop_nv(T* p) { work<T, RESOLVE, false>(p); } 100 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 101 virtual void do_oop(oop* p) { do_oop_nv(p); } 102 inline bool do_metadata_nv() { return false; } 103 virtual bool do_metadata() { return false; } 104 }; 105 106 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure { 107 public: 108 ShenandoahMarkRefsMetadataClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 109 ShenandoahMarkRefsSuperClosure(q, rp) {}; 110 111 template <class T> 112 inline void do_oop_nv(T* p) { work<T, NONE, false>(p); } 113 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 114 virtual void do_oop(oop* p) { do_oop_nv(p); } 115 inline bool do_metadata_nv() { return true; } 116 virtual bool do_metadata() { return true; } 117 }; 118 119 class ShenandoahMarkUpdateRefsMatrixClosure : public ShenandoahMarkRefsSuperClosure { 120 public: 121 ShenandoahMarkUpdateRefsMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 122 ShenandoahMarkRefsSuperClosure(q, rp) {}; 123 124 template <class T> 125 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true>(p); } 126 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 127 virtual void do_oop(oop* p) { do_oop_nv(p); } 128 inline bool do_metadata_nv() { return false; } 129 virtual bool do_metadata() { return false; } 130 }; 131 132 class ShenandoahMarkUpdateRefsMetadataMatrixClosure : public ShenandoahMarkRefsSuperClosure { 133 public: 134 ShenandoahMarkUpdateRefsMetadataMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 135 ShenandoahMarkRefsSuperClosure(q, rp) {}; 136 137 template <class T> 138 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true>(p); } 139 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 140 virtual void do_oop(oop* p) { do_oop_nv(p); } 141 inline bool do_metadata_nv() { return true; } 142 virtual bool do_metadata() { return true; } 143 }; 144 145 class ShenandoahMarkRefsMatrixClosure : public ShenandoahMarkRefsSuperClosure { 146 public: 147 ShenandoahMarkRefsMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 148 ShenandoahMarkRefsSuperClosure(q, rp) {}; 149 150 template <class T> 151 inline void do_oop_nv(T* p) { work<T, NONE, true>(p); } 152 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 153 virtual void do_oop(oop* p) { do_oop_nv(p); } 154 inline bool do_metadata_nv() { return false; } 155 virtual bool do_metadata() { return false; } 156 }; 157 158 class ShenandoahMarkRefsMetadataMatrixClosure : public ShenandoahMarkRefsSuperClosure { 159 public: 160 ShenandoahMarkRefsMetadataMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) : 161 ShenandoahMarkRefsSuperClosure(q, rp) {}; 162 163 template <class T> 164 inline void do_oop_nv(T* p) { work<T, NONE, true>(p); } 165 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 166 virtual void do_oop(oop* p) { do_oop_nv(p); } 167 inline bool do_metadata_nv() { return true; } 168 virtual bool do_metadata() { return true; } 169 }; 170 171 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP