106 |
104 |
107 void set_scanned_klass(Klass* k) { _scanned_klass = k; } |
105 void set_scanned_klass(Klass* k) { _scanned_klass = k; } |
108 template <class T> void do_klass_barrier(T* p, oop new_obj); |
106 template <class T> void do_klass_barrier(T* p, oop new_obj); |
109 }; |
107 }; |
110 |
108 |
111 template <G1Barrier barrier, G1Mark do_mark_object> |
109 template <G1Barrier barrier, bool do_mark_object> |
112 class G1ParCopyClosure : public G1ParCopyHelper { |
110 class G1ParCopyClosure : public G1ParCopyHelper { |
113 private: |
111 private: |
114 template <class T> void do_oop_work(T* p); |
112 template <class T> void do_oop_work(T* p); |
115 |
113 |
116 public: |
114 public: |
121 } |
119 } |
122 |
120 |
123 template <class T> void do_oop_nv(T* p) { do_oop_work(p); } |
121 template <class T> void do_oop_nv(T* p) { do_oop_work(p); } |
124 virtual void do_oop(oop* p) { do_oop_nv(p); } |
122 virtual void do_oop(oop* p) { do_oop_nv(p); } |
125 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
123 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
126 |
124 }; |
127 G1CollectedHeap* g1() { return _g1; }; |
125 |
128 G1ParScanThreadState* pss() { return _par_scan_state; } |
126 typedef G1ParCopyClosure<G1BarrierNone, false> G1ParScanExtRootClosure; |
129 ReferenceProcessor* rp() { return _ref_processor; }; |
127 typedef G1ParCopyClosure<G1BarrierKlass, false> G1ParScanMetadataClosure; |
130 }; |
128 |
131 |
129 |
132 typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure; |
130 typedef G1ParCopyClosure<G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
133 typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure; |
131 typedef G1ParCopyClosure<G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure; |
134 typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure; |
132 |
135 // We use a separate closure to handle references during evacuation |
133 // We use a separate closure to handle references during evacuation |
136 // failure processing. |
134 // failure processing. |
137 |
135 |
138 typedef G1ParCopyClosure<G1BarrierEvac, G1MarkNone> G1ParScanHeapEvacFailureClosure; |
136 typedef G1ParCopyClosure<G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
139 |
137 |
140 class FilterIntoCSClosure: public ExtendedOopClosure { |
138 class FilterIntoCSClosure: public ExtendedOopClosure { |
141 G1CollectedHeap* _g1; |
139 G1CollectedHeap* _g1; |
142 OopClosure* _oc; |
140 OopClosure* _oc; |
143 DirtyCardToOopClosure* _dcto_cl; |
141 DirtyCardToOopClosure* _dcto_cl; |
164 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
162 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
165 bool apply_to_weak_ref_discovered_field() { return true; } |
163 bool apply_to_weak_ref_discovered_field() { return true; } |
166 }; |
164 }; |
167 |
165 |
168 // Closure for iterating over object fields during concurrent marking |
166 // Closure for iterating over object fields during concurrent marking |
169 class G1CMOopClosure : public MetadataAwareOopClosure { |
167 class G1CMOopClosure : public ExtendedOopClosure { |
170 protected: |
|
171 ConcurrentMark* _cm; |
|
172 private: |
168 private: |
173 G1CollectedHeap* _g1h; |
169 G1CollectedHeap* _g1h; |
|
170 ConcurrentMark* _cm; |
174 CMTask* _task; |
171 CMTask* _task; |
175 public: |
172 public: |
176 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task); |
173 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task); |
177 template <class T> void do_oop_nv(T* p); |
174 template <class T> void do_oop_nv(T* p); |
178 virtual void do_oop( oop* p) { do_oop_nv(p); } |
175 virtual void do_oop( oop* p) { do_oop_nv(p); } |
179 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
176 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
180 }; |
177 }; |
181 |
178 |
182 // Closure to scan the root regions during concurrent marking |
179 // Closure to scan the root regions during concurrent marking |
183 class G1RootRegionScanClosure : public MetadataAwareOopClosure { |
180 class G1RootRegionScanClosure : public ExtendedOopClosure { |
184 private: |
181 private: |
185 G1CollectedHeap* _g1h; |
182 G1CollectedHeap* _g1h; |
186 ConcurrentMark* _cm; |
183 ConcurrentMark* _cm; |
187 uint _worker_id; |
184 uint _worker_id; |
188 public: |
185 public: |