91
92 G1RemSet(G1CollectedHeap* g1,
93 CardTableModRefBS* ct_bs,
94 G1HotCardCache* hot_card_cache);
95 ~G1RemSet();
96
97 // Invoke "cl->do_oop" on all pointers into the collection set
98 // from objects in regions outside the collection set (having
99 // invoked "cl->set_region" to set the "from" region correctly
100 // beforehand.)
101 //
102 // Apply non_heap_roots on the oops of the unmarked nmethods
103 // on the strong code roots list for each region in the
104 // collection set.
105 //
106 // The "worker_i" param is for the parallel case where the id
107 // of the worker thread calling this function can be helpful in
108 // partitioning the work to be done. It should be the same as
109 // the "i" passed to the calling thread's work(i) function.
110 // In the sequential case this param will be ignored.
111 //
112 // Returns the number of cards scanned while looking for pointers
113 // into the collection set.
114 size_t oops_into_collection_set_do(G1ParPushHeapRSClosure* cl,
115 CodeBlobClosure* heap_region_codeblobs,
116 uint worker_i);
117
118 // Prepare for and cleanup after an oops_into_collection_set_do
119 // call. Must call each of these once before and after (in sequential
120 // code) any threads call oops_into_collection_set_do. (This offers an
121 // opportunity to sequential setup and teardown of structures needed by a
122 // parallel iteration over the CS's RS.)
123 void prepare_for_oops_into_collection_set_do();
124 void cleanup_after_oops_into_collection_set_do();
125
126 size_t scan_rem_set(G1ParPushHeapRSClosure* oops_in_heap_closure,
127 CodeBlobClosure* heap_region_codeblobs,
128 uint worker_i);
129
130 G1RemSetScanState* scan_state() const { return _scan_state; }
131
132 // Flush remaining refinement buffers into the remembered set,
133 // applying oops_in_heap_closure on the references found.
134 void update_rem_set(DirtyCardQueue* into_cset_dcq, G1ParPushHeapRSClosure* oops_in_heap_closure, uint worker_i);
135
136 // Record, if necessary, the fact that *p (where "p" is in region "from",
137 // which is required to be non-NULL) has changed to a new non-NULL value.
138 template <class T> void par_write_ref(HeapRegion* from, T* p, uint tid);
139
140 // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
141 // or card, respectively, such that a region or card with a corresponding
142 // 0 bit contains no part of any live object. Eliminates any remembered
143 // set entries that correspond to dead heap ranges. "worker_num" is the
144 // parallel thread id of the current thread, and "hrclaimer" is the
145 // HeapRegionClaimer that should be used.
146 void scrub(uint worker_num, HeapRegionClaimer* hrclaimer);
168 return _conc_refine_cards;
169 }
170
171 void create_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
172 void finalize_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
173
174 // Verify that the liveness count data created concurrently matches one created
175 // during this safepoint.
176 void verify_card_live_data(WorkGang* workers, G1CMBitMap* actual_bitmap);
177
178 void clear_card_live_data(WorkGang* workers);
179
180 #ifdef ASSERT
181 void verify_card_live_data_is_clear();
182 #endif
183 };
184
185 class G1ScanRSClosure : public HeapRegionClosure {
186 G1RemSetScanState* _scan_state;
187
188 size_t _cards_done;
189 size_t _cards;
190 G1CollectedHeap* _g1h;
191
192 G1ParPushHeapRSClosure* _push_heap_cl;
193 CodeBlobClosure* _code_root_cl;
194
195 G1BlockOffsetTable* _bot;
196 G1SATBCardTableModRefBS *_ct_bs;
197
198 double _strong_code_root_scan_time_sec;
199 uint _worker_i;
200 size_t _block_size;
201
202 void scan_card(size_t index, HeapWord* card_start, HeapRegion *r);
203 void scan_strong_code_roots(HeapRegion* r);
204 public:
205 G1ScanRSClosure(G1RemSetScanState* scan_state,
206 G1ParPushHeapRSClosure* push_heap_cl,
207 CodeBlobClosure* code_root_cl,
208 uint worker_i);
209
210 bool doHeapRegion(HeapRegion* r);
211
212 double strong_code_root_scan_time_sec() {
213 return _strong_code_root_scan_time_sec;
214 }
215
216 size_t cards_done() { return _cards_done;}
217 size_t cards_looked_up() { return _cards;}
218 };
219
220 class UpdateRSOopClosure: public ExtendedOopClosure {
221 HeapRegion* _from;
222 G1RemSet* _rs;
223 uint _worker_i;
224
225 template <class T> void do_oop_work(T* p);
226
227 public:
228 UpdateRSOopClosure(G1RemSet* rs, uint worker_i = 0) :
229 _from(NULL), _rs(rs), _worker_i(worker_i)
230 {}
231
232 void set_from(HeapRegion* from) {
233 assert(from != NULL, "from region must be non-NULL");
234 _from = from;
235 }
236
237 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
|
91
92 G1RemSet(G1CollectedHeap* g1,
93 CardTableModRefBS* ct_bs,
94 G1HotCardCache* hot_card_cache);
95 ~G1RemSet();
96
97 // Invoke "cl->do_oop" on all pointers into the collection set
98 // from objects in regions outside the collection set (having
99 // invoked "cl->set_region" to set the "from" region correctly
100 // beforehand.)
101 //
102 // Apply non_heap_roots on the oops of the unmarked nmethods
103 // on the strong code roots list for each region in the
104 // collection set.
105 //
106 // The "worker_i" param is for the parallel case where the id
107 // of the worker thread calling this function can be helpful in
108 // partitioning the work to be done. It should be the same as
109 // the "i" passed to the calling thread's work(i) function.
110 // In the sequential case this param will be ignored.
111 void oops_into_collection_set_do(G1ParPushHeapRSClosure* cl,
112 CodeBlobClosure* heap_region_codeblobs,
113 uint worker_i);
114
115 // Prepare for and cleanup after an oops_into_collection_set_do
116 // call. Must call each of these once before and after (in sequential
117 // code) any threads call oops_into_collection_set_do. (This offers an
118 // opportunity to sequential setup and teardown of structures needed by a
119 // parallel iteration over the CS's RS.)
120 void prepare_for_oops_into_collection_set_do();
121 void cleanup_after_oops_into_collection_set_do();
122
123 void scan_rem_set(G1ParPushHeapRSClosure* oops_in_heap_closure,
124 CodeBlobClosure* heap_region_codeblobs,
125 uint worker_i);
126
127 G1RemSetScanState* scan_state() const { return _scan_state; }
128
129 // Flush remaining refinement buffers into the remembered set,
130 // applying oops_in_heap_closure on the references found.
131 void update_rem_set(DirtyCardQueue* into_cset_dcq, G1ParPushHeapRSClosure* oops_in_heap_closure, uint worker_i);
132
133 // Record, if necessary, the fact that *p (where "p" is in region "from",
134 // which is required to be non-NULL) has changed to a new non-NULL value.
135 template <class T> void par_write_ref(HeapRegion* from, T* p, uint tid);
136
137 // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
138 // or card, respectively, such that a region or card with a corresponding
139 // 0 bit contains no part of any live object. Eliminates any remembered
140 // set entries that correspond to dead heap ranges. "worker_num" is the
141 // parallel thread id of the current thread, and "hrclaimer" is the
142 // HeapRegionClaimer that should be used.
143 void scrub(uint worker_num, HeapRegionClaimer* hrclaimer);
165 return _conc_refine_cards;
166 }
167
168 void create_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
169 void finalize_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
170
171 // Verify that the liveness count data created concurrently matches one created
172 // during this safepoint.
173 void verify_card_live_data(WorkGang* workers, G1CMBitMap* actual_bitmap);
174
175 void clear_card_live_data(WorkGang* workers);
176
177 #ifdef ASSERT
178 void verify_card_live_data_is_clear();
179 #endif
180 };
181
182 class G1ScanRSClosure : public HeapRegionClosure {
183 G1RemSetScanState* _scan_state;
184
185 size_t _cards_scanned;
186 size_t _cards_claimed;
187 size_t _cards_skipped;
188
189 G1CollectedHeap* _g1h;
190
191 G1ParPushHeapRSClosure* _push_heap_cl;
192 CodeBlobClosure* _code_root_cl;
193
194 G1BlockOffsetTable* _bot;
195 G1SATBCardTableModRefBS *_ct_bs;
196
197 double _strong_code_root_scan_time_sec;
198 uint _worker_i;
199 size_t _block_size;
200
201 void scan_card(size_t index, HeapWord* card_start, HeapRegion *r);
202 void scan_strong_code_roots(HeapRegion* r);
203 public:
204 G1ScanRSClosure(G1RemSetScanState* scan_state,
205 G1ParPushHeapRSClosure* push_heap_cl,
206 CodeBlobClosure* code_root_cl,
207 uint worker_i);
208
209 bool doHeapRegion(HeapRegion* r);
210
211 double strong_code_root_scan_time_sec() {
212 return _strong_code_root_scan_time_sec;
213 }
214
215 size_t cards_scanned() const { return _cards_scanned; }
216 size_t cards_claimed() const { return _cards_claimed; }
217 size_t cards_skipped() const { return _cards_skipped; }
218 };
219
220 class UpdateRSOopClosure: public ExtendedOopClosure {
221 HeapRegion* _from;
222 G1RemSet* _rs;
223 uint _worker_i;
224
225 template <class T> void do_oop_work(T* p);
226
227 public:
228 UpdateRSOopClosure(G1RemSet* rs, uint worker_i = 0) :
229 _from(NULL), _rs(rs), _worker_i(worker_i)
230 {}
231
232 void set_from(HeapRegion* from) {
233 assert(from != NULL, "from region must be non-NULL");
234 _from = from;
235 }
236
237 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
|