Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/g1/g1OopClosures.hpp

src/share/vm/gc_implementation/g1/g1OopClosures.hpp

changeset 6992
2c6ef90f030a
parent 6939
cd43876f692e
child 7535
7ae4e26cb1e0
child 7651
c132be0fb74d
child 7971
b554c7fa9478
equal deleted inserted replaced
6991:882004b9e7e1 6992:2c6ef90f030a
22 * 22 *
23 */ 23 */
24 24
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
27
28 #include "memory/iterator.hpp"
27 29
28 class HeapRegion; 30 class HeapRegion;
29 class G1CollectedHeap; 31 class G1CollectedHeap;
30 class G1RemSet; 32 class G1RemSet;
31 class ConcurrentMark; 33 class ConcurrentMark;
104 106
105 void set_scanned_klass(Klass* k) { _scanned_klass = k; } 107 void set_scanned_klass(Klass* k) { _scanned_klass = k; }
106 template <class T> void do_klass_barrier(T* p, oop new_obj); 108 template <class T> void do_klass_barrier(T* p, oop new_obj);
107 }; 109 };
108 110
109 template <G1Barrier barrier, bool do_mark_object> 111 template <G1Barrier barrier, G1Mark do_mark_object>
110 class G1ParCopyClosure : public G1ParCopyHelper { 112 class G1ParCopyClosure : public G1ParCopyHelper {
111 private: 113 private:
112 template <class T> void do_oop_work(T* p); 114 template <class T> void do_oop_work(T* p);
113 115
114 public: 116 public:
119 } 121 }
120 122
121 template <class T> void do_oop_nv(T* p) { do_oop_work(p); } 123 template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
122 virtual void do_oop(oop* p) { do_oop_nv(p); } 124 virtual void do_oop(oop* p) { do_oop_nv(p); }
123 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 125 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
124 }; 126
125 127 G1CollectedHeap* g1() { return _g1; };
126 typedef G1ParCopyClosure<G1BarrierNone, false> G1ParScanExtRootClosure; 128 G1ParScanThreadState* pss() { return _par_scan_state; }
127 typedef G1ParCopyClosure<G1BarrierKlass, false> G1ParScanMetadataClosure; 129 ReferenceProcessor* rp() { return _ref_processor; };
128 130 };
129 131
130 typedef G1ParCopyClosure<G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; 132 typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
131 typedef G1ParCopyClosure<G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure; 133 typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure;
132 134 typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure;
133 // We use a separate closure to handle references during evacuation 135 // We use a separate closure to handle references during evacuation
134 // failure processing. 136 // failure processing.
135 137
136 typedef G1ParCopyClosure<G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; 138 typedef G1ParCopyClosure<G1BarrierEvac, G1MarkNone> G1ParScanHeapEvacFailureClosure;
137 139
138 class FilterIntoCSClosure: public ExtendedOopClosure { 140 class FilterIntoCSClosure: public ExtendedOopClosure {
139 G1CollectedHeap* _g1; 141 G1CollectedHeap* _g1;
140 OopClosure* _oc; 142 OopClosure* _oc;
141 DirtyCardToOopClosure* _dcto_cl; 143 DirtyCardToOopClosure* _dcto_cl;
162 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 164 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
163 bool apply_to_weak_ref_discovered_field() { return true; } 165 bool apply_to_weak_ref_discovered_field() { return true; }
164 }; 166 };
165 167
166 // Closure for iterating over object fields during concurrent marking 168 // Closure for iterating over object fields during concurrent marking
167 class G1CMOopClosure : public ExtendedOopClosure { 169 class G1CMOopClosure : public MetadataAwareOopClosure {
170 protected:
171 ConcurrentMark* _cm;
168 private: 172 private:
169 G1CollectedHeap* _g1h; 173 G1CollectedHeap* _g1h;
170 ConcurrentMark* _cm;
171 CMTask* _task; 174 CMTask* _task;
172 public: 175 public:
173 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task); 176 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task);
174 template <class T> void do_oop_nv(T* p); 177 template <class T> void do_oop_nv(T* p);
175 virtual void do_oop( oop* p) { do_oop_nv(p); } 178 virtual void do_oop( oop* p) { do_oop_nv(p); }
176 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 179 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
177 }; 180 };
178 181
179 // Closure to scan the root regions during concurrent marking 182 // Closure to scan the root regions during concurrent marking
180 class G1RootRegionScanClosure : public ExtendedOopClosure { 183 class G1RootRegionScanClosure : public MetadataAwareOopClosure {
181 private: 184 private:
182 G1CollectedHeap* _g1h; 185 G1CollectedHeap* _g1h;
183 ConcurrentMark* _cm; 186 ConcurrentMark* _cm;
184 uint _worker_id; 187 uint _worker_id;
185 public: 188 public:

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial