38 // Closure for iterating roots from a particular generation |
38 // Closure for iterating roots from a particular generation |
39 // Note: all classes deriving from this MUST call this do_barrier |
39 // Note: all classes deriving from this MUST call this do_barrier |
40 // method at the end of their own do_oop method! |
40 // method at the end of their own do_oop method! |
41 // Note: no do_oop defined, this is an abstract class. |
41 // Note: no do_oop defined, this is an abstract class. |
42 |
42 |
43 class OopsInGenClosure : public ExtendedOopClosure { |
43 class OopsInGenClosure : public OopIterateClosure { |
44 private: |
44 private: |
45 Generation* _orig_gen; // generation originally set in ctor |
45 Generation* _orig_gen; // generation originally set in ctor |
46 Generation* _gen; // generation being scanned |
46 Generation* _gen; // generation being scanned |
47 |
47 |
48 protected: |
48 protected: |
60 |
60 |
61 // Version for use by closures that may be called in parallel code. |
61 // Version for use by closures that may be called in parallel code. |
62 template <class T> void par_do_barrier(T* p); |
62 template <class T> void par_do_barrier(T* p); |
63 |
63 |
64 public: |
64 public: |
65 OopsInGenClosure() : ExtendedOopClosure(NULL), |
65 OopsInGenClosure() : OopIterateClosure(NULL), |
66 _orig_gen(NULL), _gen(NULL), _gen_boundary(NULL), _rs(NULL) {}; |
66 _orig_gen(NULL), _gen(NULL), _gen_boundary(NULL), _rs(NULL) {}; |
67 |
67 |
68 OopsInGenClosure(Generation* gen); |
68 OopsInGenClosure(Generation* gen); |
69 void set_generation(Generation* gen); |
69 void set_generation(Generation* gen); |
70 |
70 |
79 |
79 |
80 HeapWord* gen_boundary() { return _gen_boundary; } |
80 HeapWord* gen_boundary() { return _gen_boundary; } |
81 |
81 |
82 }; |
82 }; |
83 |
83 |
|
84 class BasicOopsInGenClosure: public OopsInGenClosure { |
|
85 public: |
|
86 BasicOopsInGenClosure() : OopsInGenClosure() {} |
|
87 BasicOopsInGenClosure(Generation* gen); |
|
88 |
|
89 virtual bool do_metadata() { return false; } |
|
90 virtual void do_klass(Klass* k) { ShouldNotReachHere(); } |
|
91 virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); } |
|
92 }; |
|
93 |
84 // Super class for scan closures. It contains code to dirty scanned class loader data. |
94 // Super class for scan closures. It contains code to dirty scanned class loader data. |
85 class OopsInClassLoaderDataOrGenClosure: public OopsInGenClosure { |
95 class OopsInClassLoaderDataOrGenClosure: public BasicOopsInGenClosure { |
86 ClassLoaderData* _scanned_cld; |
96 ClassLoaderData* _scanned_cld; |
87 public: |
97 public: |
88 OopsInClassLoaderDataOrGenClosure(Generation* g) : OopsInGenClosure(g), _scanned_cld(NULL) {} |
98 OopsInClassLoaderDataOrGenClosure(Generation* g) : BasicOopsInGenClosure(g), _scanned_cld(NULL) {} |
89 void set_scanned_cld(ClassLoaderData* cld) { |
99 void set_scanned_cld(ClassLoaderData* cld) { |
90 assert(cld == NULL || _scanned_cld == NULL, "Must be"); |
100 assert(cld == NULL || _scanned_cld == NULL, "Must be"); |
91 _scanned_cld = cld; |
101 _scanned_cld = cld; |
92 } |
102 } |
93 bool is_scanning_a_cld() { return _scanned_cld != NULL; } |
103 bool is_scanning_a_cld() { return _scanned_cld != NULL; } |
108 template <class T> inline void do_oop_work(T* p); |
118 template <class T> inline void do_oop_work(T* p); |
109 public: |
119 public: |
110 ScanClosure(DefNewGeneration* g, bool gc_barrier); |
120 ScanClosure(DefNewGeneration* g, bool gc_barrier); |
111 virtual void do_oop(oop* p); |
121 virtual void do_oop(oop* p); |
112 virtual void do_oop(narrowOop* p); |
122 virtual void do_oop(narrowOop* p); |
113 inline void do_oop_nv(oop* p); |
|
114 inline void do_oop_nv(narrowOop* p); |
|
115 }; |
123 }; |
116 |
124 |
117 // Closure for scanning DefNewGeneration. |
125 // Closure for scanning DefNewGeneration. |
118 // |
126 // |
119 // This closure only performs barrier store calls on |
127 // This closure only performs barrier store calls on |
127 template <class T> inline void do_oop_work(T* p); |
135 template <class T> inline void do_oop_work(T* p); |
128 public: |
136 public: |
129 FastScanClosure(DefNewGeneration* g, bool gc_barrier); |
137 FastScanClosure(DefNewGeneration* g, bool gc_barrier); |
130 virtual void do_oop(oop* p); |
138 virtual void do_oop(oop* p); |
131 virtual void do_oop(narrowOop* p); |
139 virtual void do_oop(narrowOop* p); |
132 inline void do_oop_nv(oop* p); |
|
133 inline void do_oop_nv(narrowOop* p); |
|
134 }; |
140 }; |
135 |
141 |
136 #endif // INCLUDE_SERIALGC |
142 #endif // INCLUDE_SERIALGC |
137 |
143 |
138 class CLDScanClosure: public CLDClosure { |
144 class CLDScanClosure: public CLDClosure { |
144 bool accumulate_modified_oops) : |
150 bool accumulate_modified_oops) : |
145 _scavenge_closure(scavenge_closure), _accumulate_modified_oops(accumulate_modified_oops) {} |
151 _scavenge_closure(scavenge_closure), _accumulate_modified_oops(accumulate_modified_oops) {} |
146 void do_cld(ClassLoaderData* cld); |
152 void do_cld(ClassLoaderData* cld); |
147 }; |
153 }; |
148 |
154 |
149 class FilteringClosure: public ExtendedOopClosure { |
155 class FilteringClosure: public OopIterateClosure { |
150 private: |
156 private: |
151 HeapWord* _boundary; |
157 HeapWord* _boundary; |
152 ExtendedOopClosure* _cl; |
158 OopIterateClosure* _cl; |
153 protected: |
159 protected: |
154 template <class T> inline void do_oop_work(T* p); |
160 template <class T> inline void do_oop_work(T* p); |
155 public: |
161 public: |
156 FilteringClosure(HeapWord* boundary, ExtendedOopClosure* cl) : |
162 FilteringClosure(HeapWord* boundary, OopIterateClosure* cl) : |
157 ExtendedOopClosure(cl->ref_discoverer()), _boundary(boundary), |
163 OopIterateClosure(cl->ref_discoverer()), _boundary(boundary), |
158 _cl(cl) {} |
164 _cl(cl) {} |
159 virtual void do_oop(oop* p); |
165 virtual void do_oop(oop* p); |
160 virtual void do_oop(narrowOop* p); |
166 virtual void do_oop(narrowOop* p); |
161 inline void do_oop_nv(oop* p); |
167 virtual bool do_metadata() { assert(!_cl->do_metadata(), "assumption broken, must change to 'return _cl->do_metadata()'"); return false; } |
162 inline void do_oop_nv(narrowOop* p); |
168 virtual void do_klass(Klass*) { ShouldNotReachHere(); } |
163 virtual bool do_metadata() { return do_metadata_nv(); } |
169 virtual void do_cld(ClassLoaderData*) { ShouldNotReachHere(); } |
164 inline bool do_metadata_nv() { assert(!_cl->do_metadata(), "assumption broken, must change to 'return _cl->do_metadata()'"); return false; } |
|
165 }; |
170 }; |
166 |
171 |
167 #if INCLUDE_SERIALGC |
172 #if INCLUDE_SERIALGC |
168 |
173 |
169 // Closure for scanning DefNewGeneration's weak references. |
174 // Closure for scanning DefNewGeneration's weak references. |
177 template <class T> inline void do_oop_work(T* p); |
182 template <class T> inline void do_oop_work(T* p); |
178 public: |
183 public: |
179 ScanWeakRefClosure(DefNewGeneration* g); |
184 ScanWeakRefClosure(DefNewGeneration* g); |
180 virtual void do_oop(oop* p); |
185 virtual void do_oop(oop* p); |
181 virtual void do_oop(narrowOop* p); |
186 virtual void do_oop(narrowOop* p); |
182 inline void do_oop_nv(oop* p); |
|
183 inline void do_oop_nv(narrowOop* p); |
|
184 }; |
187 }; |
185 |
188 |
186 #endif // INCLUDE_SERIALGC |
189 #endif // INCLUDE_SERIALGC |
187 |
190 |
188 #endif // SHARE_VM_GC_SHARED_GENOOPCLOSURES_HPP |
191 #endif // SHARE_VM_GC_SHARED_GENOOPCLOSURES_HPP |