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 resolve (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 ShenandoahUpdateHeapRefsClosure : public BasicOopIterateClosure { 188 private: 189 ShenandoahHeap* _heap; 190 191 template <class T> 192 void do_oop_work(T* p); 193 194 public: 195 ShenandoahUpdateHeapRefsClosure() : 196 _heap(ShenandoahHeap::heap()) {} 197 198 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 199 virtual void do_oop(oop* p) { do_oop_work(p); } 200 }; 201 202 class ShenandoahTraversalSuperClosure : public MetadataVisitingOopIterateClosure { 203 private: 204 ShenandoahTraversalGC* const _traversal_gc; 205 Thread* const _thread; 206 ShenandoahObjToScanQueue* const _queue; 207 ShenandoahMarkingContext* const _mark_context; 208 protected: 209 ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 210 MetadataVisitingOopIterateClosure(rp), 211 _traversal_gc(ShenandoahHeap::heap()->traversal_gc()), 212 _thread(Thread::current()), 213 _queue(q), 214 _mark_context(ShenandoahHeap::heap()->marking_context()) { 215 } 216 217 template <class T, bool STRING_DEDUP, bool DEGEN, bool ATOMIC_UPDATE> 218 void work(T* p); 219 220 }; 221 222 class ShenandoahTraversalRootsClosure : public ShenandoahTraversalSuperClosure { 223 private: 224 template <class T> 225 inline void do_oop_work(T* p) { work<T, false, false, false>(p); } 226 227 public: 228 ShenandoahTraversalRootsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 229 ShenandoahTraversalSuperClosure(q, rp) {} 230 231 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 232 virtual void do_oop(oop* p) { do_oop_work(p); } 233 234 virtual bool do_metadata() { return false; } 235 }; 236 237 class ShenandoahTraversalClosure : public ShenandoahTraversalSuperClosure { 238 private: 239 template <class T> 240 inline void do_oop_work(T* p) { work<T, false, false, true>(p); } 241 242 public: 243 ShenandoahTraversalClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 244 ShenandoahTraversalSuperClosure(q, rp) {} 245 246 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 247 virtual void do_oop(oop* p) { do_oop_work(p); } 248 249 virtual bool do_metadata() { return false; } 250 }; 251 252 class ShenandoahTraversalMetadataClosure : public ShenandoahTraversalSuperClosure { 253 private: 254 template <class T> 255 inline void do_oop_work(T* p) { work<T, false, false, true>(p); } 256 257 public: 258 ShenandoahTraversalMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 259 ShenandoahTraversalSuperClosure(q, rp) {} 260 261 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 262 virtual void do_oop(oop* p) { do_oop_work(p); } 263 264 virtual bool do_metadata() { return true; } 265 }; 266 267 class ShenandoahTraversalDedupClosure : public ShenandoahTraversalSuperClosure { 268 private: 269 template <class T> 270 inline void do_oop_work(T* p) { work<T, true, false, true>(p); } 271 272 public: 273 ShenandoahTraversalDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 274 ShenandoahTraversalSuperClosure(q, rp) {} 275 276 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 277 virtual void do_oop(oop* p) { do_oop_work(p); } 278 279 virtual bool do_metadata() { return false; } 280 }; 281 282 class ShenandoahTraversalMetadataDedupClosure : public ShenandoahTraversalSuperClosure { 283 private: 284 template <class T> 285 inline void do_oop_work(T* p) { work<T, true, false, true>(p); } 286 287 public: 288 ShenandoahTraversalMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 289 ShenandoahTraversalSuperClosure(q, rp) {} 290 291 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 292 virtual void do_oop(oop* p) { do_oop_work(p); } 293 294 virtual bool do_metadata() { return true; } 295 }; 296 297 class ShenandoahTraversalDegenClosure : public ShenandoahTraversalSuperClosure { 298 private: 299 template <class T> 300 inline void do_oop_work(T* p) { work<T, false, true, false>(p); } 301 302 public: 303 ShenandoahTraversalDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 304 ShenandoahTraversalSuperClosure(q, rp) {} 305 306 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 307 virtual void do_oop(oop* p) { do_oop_work(p); } 308 309 virtual bool do_metadata() { return false; } 310 }; 311 312 class ShenandoahTraversalMetadataDegenClosure : public ShenandoahTraversalSuperClosure { 313 private: 314 template <class T> 315 inline void do_oop_work(T* p) { work<T, false, true, false>(p); } 316 317 public: 318 ShenandoahTraversalMetadataDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 319 ShenandoahTraversalSuperClosure(q, rp) {} 320 321 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 322 virtual void do_oop(oop* p) { do_oop_work(p); } 323 324 virtual bool do_metadata() { return true; } 325 }; 326 327 class ShenandoahTraversalDedupDegenClosure : public ShenandoahTraversalSuperClosure { 328 private: 329 template <class T> 330 inline void do_oop_work(T* p) { work<T, true, true, false>(p); } 331 332 public: 333 ShenandoahTraversalDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 334 ShenandoahTraversalSuperClosure(q, rp) {} 335 336 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 337 virtual void do_oop(oop* p) { do_oop_work(p); } 338 339 virtual bool do_metadata() { return false; } 340 }; 341 342 class ShenandoahTraversalMetadataDedupDegenClosure : public ShenandoahTraversalSuperClosure { 343 private: 344 template <class T> 345 inline void do_oop_work(T* p) { work<T, true, true, false>(p); } 346 347 public: 348 ShenandoahTraversalMetadataDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) : 349 ShenandoahTraversalSuperClosure(q, rp) {} 350 351 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 352 virtual void do_oop(oop* p) { do_oop_work(p); } 353 354 virtual bool do_metadata() { return true; } 355 }; 356 357 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP