77 class G1ParScanClosure : public G1ParClosureSuper {
78 public:
79 G1ParScanClosure(G1CollectedHeap* g1) : G1ParClosureSuper(g1) { }
80
81 template <class T> void do_oop_nv(T* p);
82 virtual void do_oop(oop* p) { do_oop_nv(p); }
83 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
84
85 void set_ref_processor(ReferenceProcessor* ref_processor) { _ref_processor = ref_processor; }
86 };
87
88 // Add back base class for metadata
89 class G1ParCopyHelper : public G1ParClosureSuper {
90 protected:
91 Klass* _scanned_klass;
92 ConcurrentMark* _cm;
93
94 // Mark the object if it's not already marked. This is used to mark
95 // objects pointed to by roots that are guaranteed not to move
96 // during the GC (i.e., non-CSet objects). It is MT-safe.
97 void mark_object(oop obj);
98
99 // Mark the object if it's not already marked. This is used to mark
100 // objects pointed to by roots that have been forwarded during a
101 // GC. It is MT-safe.
102 void mark_forwarded_object(oop from_obj, oop to_obj);
103 public:
104 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
105 G1ParCopyHelper(G1CollectedHeap* g1);
106
107 void set_scanned_klass(Klass* k) { _scanned_klass = k; }
108 template <class T> void do_klass_barrier(T* p, oop new_obj);
109 };
110
111 enum G1Barrier {
112 G1BarrierNone,
113 G1BarrierKlass
114 };
115
116 enum G1Mark {
117 G1MarkNone,
118 G1MarkFromRoot,
119 G1MarkPromotedFromRoot
120 };
121
122 template <G1Barrier barrier, G1Mark do_mark_object>
123 class G1ParCopyClosure : public G1ParCopyHelper {
124 private:
125 template <class T> void do_oop_work(T* p);
126
127 public:
128 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
129 G1ParCopyHelper(g1, par_scan_state) {
130 assert(_ref_processor == NULL, "sanity");
131 }
132
133 G1ParCopyClosure(G1CollectedHeap* g1) : G1ParCopyHelper(g1) {
134 assert(_ref_processor == NULL, "sanity");
135 }
136
137 template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
138 virtual void do_oop(oop* p) { do_oop_nv(p); }
139 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
140
141 G1CollectedHeap* g1() { return _g1; };
142 G1ParScanThreadState* pss() { return _par_scan_state; }
143 };
144
145 typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
146 typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure;
147 typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure;
148 // We use a separate closure to handle references during evacuation
149 // failure processing.
150
151 class FilterIntoCSClosure: public ExtendedOopClosure {
152 G1CollectedHeap* _g1;
153 OopClosure* _oc;
154 DirtyCardToOopClosure* _dcto_cl;
155 public:
156 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl,
157 G1CollectedHeap* g1,
158 OopClosure* oc) :
159 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) { }
160
161 template <class T> void do_oop_nv(T* p);
162 virtual void do_oop(oop* p) { do_oop_nv(p); }
163 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
164 bool apply_to_weak_ref_discovered_field() { return true; }
165 };
166
167 class FilterOutOfRegionClosure: public ExtendedOopClosure {
168 HeapWord* _r_bottom;
169 HeapWord* _r_end;
|
77 class G1ParScanClosure : public G1ParClosureSuper {
78 public:
79 G1ParScanClosure(G1CollectedHeap* g1) : G1ParClosureSuper(g1) { }
80
81 template <class T> void do_oop_nv(T* p);
82 virtual void do_oop(oop* p) { do_oop_nv(p); }
83 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
84
85 void set_ref_processor(ReferenceProcessor* ref_processor) { _ref_processor = ref_processor; }
86 };
87
88 // Add back base class for metadata
89 class G1ParCopyHelper : public G1ParClosureSuper {
90 protected:
91 Klass* _scanned_klass;
92 ConcurrentMark* _cm;
93
94 // Mark the object if it's not already marked. This is used to mark
95 // objects pointed to by roots that are guaranteed not to move
96 // during the GC (i.e., non-CSet objects). It is MT-safe.
97 inline void mark_object(oop obj);
98
99 // Mark the object if it's not already marked. This is used to mark
100 // objects pointed to by roots that have been forwarded during a
101 // GC. It is MT-safe.
102 inline void mark_forwarded_object(oop from_obj, oop to_obj);
103 public:
104 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
105 G1ParCopyHelper(G1CollectedHeap* g1);
106
107 void set_scanned_klass(Klass* k) { _scanned_klass = k; }
108 template <class T> inline void do_klass_barrier(T* p, oop new_obj);
109 };
110
111 enum G1Barrier {
112 G1BarrierNone,
113 G1BarrierKlass
114 };
115
116 enum G1Mark {
117 G1MarkNone,
118 G1MarkFromRoot,
119 G1MarkPromotedFromRoot
120 };
121
122 template <G1Barrier barrier, G1Mark do_mark_object>
123 class G1ParCopyClosure : public G1ParCopyHelper {
124 private:
125 template <class T> void do_oop_work(T* p);
126
127 public:
128 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
129 G1ParCopyHelper(g1, par_scan_state) {
130 assert(_ref_processor == NULL, "sanity");
131 }
132
133 G1ParCopyClosure(G1CollectedHeap* g1) : G1ParCopyHelper(g1) {
134 assert(_ref_processor == NULL, "sanity");
135 }
136
137 template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
138 virtual void do_oop(oop* p) { do_oop_nv(p); }
139 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
140 };
141
142 class G1KlassScanClosure : public KlassClosure {
143 G1ParCopyHelper* _closure;
144 bool _process_only_dirty;
145 int _count;
146 public:
147 G1KlassScanClosure(G1ParCopyHelper* closure, bool process_only_dirty)
148 : _process_only_dirty(process_only_dirty), _closure(closure), _count(0) {}
149 void do_klass(Klass* klass);
150 };
151
152 class FilterIntoCSClosure: public ExtendedOopClosure {
153 G1CollectedHeap* _g1;
154 OopClosure* _oc;
155 DirtyCardToOopClosure* _dcto_cl;
156 public:
157 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl,
158 G1CollectedHeap* g1,
159 OopClosure* oc) :
160 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) { }
161
162 template <class T> void do_oop_nv(T* p);
163 virtual void do_oop(oop* p) { do_oop_nv(p); }
164 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
165 bool apply_to_weak_ref_discovered_field() { return true; }
166 };
167
168 class FilterOutOfRegionClosure: public ExtendedOopClosure {
169 HeapWord* _r_bottom;
170 HeapWord* _r_end;
|