1 /* 2 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. 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 * 23 */ 24 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARNEW_PAROOPCLOSURES_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_PARNEW_PAROOPCLOSURES_HPP 27 28 #include "memory/genOopClosures.hpp" 29 #include "memory/padded.hpp" 30 31 // Closures for ParNewGeneration 32 33 class ParScanThreadState; 34 class ParNewGeneration; 35 typedef Padded<OopTaskQueue> ObjToScanQueue; 36 typedef GenericTaskQueueSet<ObjToScanQueue, mtGC> ObjToScanQueueSet; 37 class ParallelTaskTerminator; 38 39 class ParScanClosure: public OopsInKlassOrGenClosure { 40 protected: 41 ParScanThreadState* _par_scan_state; 42 ParNewGeneration* _g; 43 HeapWord* _boundary; 44 template <class T> void inline par_do_barrier(T* p); 45 template <class T> void inline do_oop_work(T* p, 46 bool gc_barrier, 47 bool root_scan); 48 public: 49 ParScanClosure() : OopsInKlassOrGenClosure(NULL) { } 50 ParScanClosure(ParNewGeneration* g, ParScanThreadState* par_scan_state); 51 }; 52 53 class ParScanWithBarrierClosure: public ParScanClosure { 54 public: 55 ParScanWithBarrierClosure() {} 56 ParScanWithBarrierClosure(ParNewGeneration* g, 57 ParScanThreadState* par_scan_state) : 58 ParScanClosure(g, par_scan_state) {} 59 virtual void do_oop(oop* p); 60 virtual void do_oop(narrowOop* p); 61 inline void do_oop_nv(oop* p); 62 inline void do_oop_nv(narrowOop* p); 63 }; 64 65 class ParScanWithoutBarrierClosure: public ParScanClosure { 66 public: 67 ParScanWithoutBarrierClosure() {} 68 ParScanWithoutBarrierClosure(ParNewGeneration* g, 69 ParScanThreadState* par_scan_state) : 70 ParScanClosure(g, par_scan_state) {} 71 virtual void do_oop(oop* p); 72 virtual void do_oop(narrowOop* p); 73 inline void do_oop_nv(oop* p); 74 inline void do_oop_nv(narrowOop* p); 75 }; 76 77 class ParRootScanWithBarrierTwoGensClosure: public ParScanClosure { 78 public: 79 ParRootScanWithBarrierTwoGensClosure() {} 80 ParRootScanWithBarrierTwoGensClosure(ParNewGeneration* g, 81 ParScanThreadState* par_scan_state) : 82 ParScanClosure(g, par_scan_state) {} 83 virtual void do_oop(oop* p); 84 virtual void do_oop(narrowOop* p); 85 }; 86 87 class ParRootScanWithoutBarrierClosure: public ParScanClosure { 88 public: 89 ParRootScanWithoutBarrierClosure() {} 90 ParRootScanWithoutBarrierClosure(ParNewGeneration* g, 91 ParScanThreadState* par_scan_state) : 92 ParScanClosure(g, par_scan_state) {} 93 virtual void do_oop(oop* p); 94 virtual void do_oop(narrowOop* p); 95 }; 96 97 class ParScanWeakRefClosure: public ScanWeakRefClosure { 98 protected: 99 ParScanThreadState* _par_scan_state; 100 template <class T> inline void do_oop_work(T* p); 101 public: 102 ParScanWeakRefClosure() : ScanWeakRefClosure(NULL) {} 103 ParScanWeakRefClosure(ParNewGeneration* g, 104 ParScanThreadState* par_scan_state); 105 virtual void do_oop(oop* p); 106 virtual void do_oop(narrowOop* p); 107 inline void do_oop_nv(oop* p); 108 inline void do_oop_nv(narrowOop* p); 109 }; 110 111 class ParEvacuateFollowersClosure: public VoidClosure { 112 private: 113 ParScanThreadState* _par_scan_state; 114 ParScanThreadState* par_scan_state() { return _par_scan_state; } 115 116 // We want to preserve the specific types here (rather than "OopClosure") 117 // for later de-virtualization of do_oop calls. 118 ParScanWithoutBarrierClosure* _to_space_closure; 119 ParScanWithoutBarrierClosure* to_space_closure() { 120 return _to_space_closure; 121 } 122 ParRootScanWithoutBarrierClosure* _to_space_root_closure; 123 ParRootScanWithoutBarrierClosure* to_space_root_closure() { 124 return _to_space_root_closure; 125 } 126 127 ParScanWithBarrierClosure* _old_gen_closure; 128 ParScanWithBarrierClosure* old_gen_closure () { 129 return _old_gen_closure; 130 } 131 ParRootScanWithBarrierTwoGensClosure* _old_gen_root_closure; 132 ParRootScanWithBarrierTwoGensClosure* old_gen_root_closure () { 133 return _old_gen_root_closure; 134 } 135 136 ParNewGeneration* _par_gen; 137 ParNewGeneration* par_gen() { return _par_gen; } 138 139 ObjToScanQueueSet* _task_queues; 140 ObjToScanQueueSet* task_queues() { return _task_queues; } 141 142 ParallelTaskTerminator* _terminator; 143 ParallelTaskTerminator* terminator() { return _terminator; } 144 public: 145 ParEvacuateFollowersClosure() {} 146 ParEvacuateFollowersClosure( 147 ParScanThreadState* par_scan_state_, 148 ParScanWithoutBarrierClosure* to_space_closure_, 149 ParScanWithBarrierClosure* old_gen_closure_, 150 ParRootScanWithoutBarrierClosure* to_space_root_closure_, 151 ParNewGeneration* par_gen_, 152 ParRootScanWithBarrierTwoGensClosure* old_gen_root_closure_, 153 ObjToScanQueueSet* task_queues_, 154 ParallelTaskTerminator* terminator_); 155 virtual void do_void(); 156 }; 157 158 #endif // SHARE_VM_GC_IMPLEMENTATION_PARNEW_PAROOPCLOSURES_HPP