59 G1ParClosureSuper(G1CollectedHeap* g1);
60 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
61 bool apply_to_weak_ref_discovered_field() { return true; }
62
63 void set_par_scan_thread_state(G1ParScanThreadState* par_scan_state);
64 };
65
66 class G1ParPushHeapRSClosure : public G1ParClosureSuper {
67 public:
68 G1ParPushHeapRSClosure(G1CollectedHeap* g1,
69 G1ParScanThreadState* par_scan_state):
70 G1ParClosureSuper(g1, par_scan_state) { }
71
72 template <class T> void do_oop_nv(T* p);
73 virtual void do_oop(oop* p) { do_oop_nv(p); }
74 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
75 };
76
77 class G1ParScanClosure : public G1ParClosureSuper {
78 public:
79 G1ParScanClosure(G1CollectedHeap* g1, ReferenceProcessor* rp) :
80 G1ParClosureSuper(g1) {
81 assert(_ref_processor == NULL, "sanity");
82 _ref_processor = rp;
83 }
84
85 template <class T> void do_oop_nv(T* p);
86 virtual void do_oop(oop* p) { do_oop_nv(p); }
87 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
88 };
89
90 // Add back base class for metadata
91 class G1ParCopyHelper : public G1ParClosureSuper {
92 protected:
93 Klass* _scanned_klass;
94 ConcurrentMark* _cm;
95
96 // Mark the object if it's not already marked. This is used to mark
97 // objects pointed to by roots that are guaranteed not to move
98 // during the GC (i.e., non-CSet objects). It is MT-safe.
99 void mark_object(oop obj);
100
101 // Mark the object if it's not already marked. This is used to mark
102 // objects pointed to by roots that have been forwarded during a
103 // GC. It is MT-safe.
104 void mark_forwarded_object(oop from_obj, oop to_obj);
105 public:
106 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
107
108 void set_scanned_klass(Klass* k) { _scanned_klass = k; }
109 template <class T> void do_klass_barrier(T* p, oop new_obj);
110 };
111
112 enum G1Barrier {
113 G1BarrierNone,
114 G1BarrierKlass
115 };
116
117 enum G1Mark {
118 G1MarkNone,
119 G1MarkFromRoot,
120 G1MarkPromotedFromRoot
121 };
122
123 template <G1Barrier barrier, G1Mark do_mark_object>
124 class G1ParCopyClosure : public G1ParCopyHelper {
125 private:
126 template <class T> void do_oop_work(T* p);
127
128 public:
129 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
130 ReferenceProcessor* rp) :
131 G1ParCopyHelper(g1, par_scan_state) {
132 assert(_ref_processor == NULL, "sanity");
133 }
134
135 template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
136 virtual void do_oop(oop* p) { do_oop_nv(p); }
137 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
138
139 G1CollectedHeap* g1() { return _g1; };
140 G1ParScanThreadState* pss() { return _par_scan_state; }
141 ReferenceProcessor* rp() { return _ref_processor; };
142 };
143
144 typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
145 typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure;
146 typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure;
147 // We use a separate closure to handle references during evacuation
148 // failure processing.
149
150 class FilterIntoCSClosure: public ExtendedOopClosure {
151 G1CollectedHeap* _g1;
|
59 G1ParClosureSuper(G1CollectedHeap* g1);
60 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
61 bool apply_to_weak_ref_discovered_field() { return true; }
62
63 void set_par_scan_thread_state(G1ParScanThreadState* par_scan_state);
64 };
65
66 class G1ParPushHeapRSClosure : public G1ParClosureSuper {
67 public:
68 G1ParPushHeapRSClosure(G1CollectedHeap* g1,
69 G1ParScanThreadState* par_scan_state):
70 G1ParClosureSuper(g1, par_scan_state) { }
71
72 template <class T> void do_oop_nv(T* p);
73 virtual void do_oop(oop* p) { do_oop_nv(p); }
74 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
75 };
76
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 ReferenceProcessor* rp) :
130 G1ParCopyHelper(g1, par_scan_state) {
131 assert(_ref_processor == NULL, "sanity");
132 }
133
134 G1ParCopyClosure(G1CollectedHeap* g1) : G1ParCopyHelper(g1) {
135 assert(_ref_processor == NULL, "sanity");
136 }
137
138 template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
139 virtual void do_oop(oop* p) { do_oop_nv(p); }
140 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
141
142 G1CollectedHeap* g1() { return _g1; };
143 G1ParScanThreadState* pss() { return _par_scan_state; }
144 ReferenceProcessor* rp() { return _ref_processor; };
145 };
146
147 typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
148 typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure;
149 typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure;
150 // We use a separate closure to handle references during evacuation
151 // failure processing.
152
153 class FilterIntoCSClosure: public ExtendedOopClosure {
154 G1CollectedHeap* _g1;
|