144 |
144 |
145 void RefProcTaskExecutor::execute(ProcessTask& task) |
145 void RefProcTaskExecutor::execute(ProcessTask& task) |
146 { |
146 { |
147 ParallelScavengeHeap* heap = PSParallelCompact::gc_heap(); |
147 ParallelScavengeHeap* heap = PSParallelCompact::gc_heap(); |
148 uint parallel_gc_threads = heap->gc_task_manager()->workers(); |
148 uint parallel_gc_threads = heap->gc_task_manager()->workers(); |
149 ChunkTaskQueueSet* qset = ParCompactionManager::chunk_array(); |
149 RegionTaskQueueSet* qset = ParCompactionManager::region_array(); |
150 ParallelTaskTerminator terminator(parallel_gc_threads, qset); |
150 ParallelTaskTerminator terminator(parallel_gc_threads, qset); |
151 GCTaskQueue* q = GCTaskQueue::create(); |
151 GCTaskQueue* q = GCTaskQueue::create(); |
152 for(uint i=0; i<parallel_gc_threads; i++) { |
152 for(uint i=0; i<parallel_gc_threads; i++) { |
153 q->enqueue(new RefProcTaskProxy(task, i)); |
153 q->enqueue(new RefProcTaskProxy(task, i)); |
154 } |
154 } |
203 } |
203 } |
204 } |
204 } |
205 } |
205 } |
206 |
206 |
207 // |
207 // |
208 // StealChunkCompactionTask |
208 // StealRegionCompactionTask |
209 // |
209 // |
210 |
210 |
211 |
211 |
212 StealChunkCompactionTask::StealChunkCompactionTask(ParallelTaskTerminator* t) : |
212 StealRegionCompactionTask::StealRegionCompactionTask(ParallelTaskTerminator* t): |
213 _terminator(t) {}; |
213 _terminator(t) {} |
214 |
214 |
215 void StealChunkCompactionTask::do_it(GCTaskManager* manager, uint which) { |
215 void StealRegionCompactionTask::do_it(GCTaskManager* manager, uint which) { |
216 assert(Universe::heap()->is_gc_active(), "called outside gc"); |
216 assert(Universe::heap()->is_gc_active(), "called outside gc"); |
217 |
217 |
218 NOT_PRODUCT(TraceTime tm("StealChunkCompactionTask", |
218 NOT_PRODUCT(TraceTime tm("StealRegionCompactionTask", |
219 PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); |
219 PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); |
220 |
220 |
221 ParCompactionManager* cm = |
221 ParCompactionManager* cm = |
222 ParCompactionManager::gc_thread_compaction_manager(which); |
222 ParCompactionManager::gc_thread_compaction_manager(which); |
223 |
223 |
224 // Has to drain stacks first because there may be chunks on |
224 // Has to drain stacks first because there may be regions on |
225 // preloaded onto the stack and this thread may never have |
225 // preloaded onto the stack and this thread may never have |
226 // done a draining task. Are the draining tasks needed? |
226 // done a draining task. Are the draining tasks needed? |
227 |
227 |
228 cm->drain_chunk_stacks(); |
228 cm->drain_region_stacks(); |
229 |
229 |
230 size_t chunk_index = 0; |
230 size_t region_index = 0; |
231 int random_seed = 17; |
231 int random_seed = 17; |
232 |
232 |
233 // If we're the termination task, try 10 rounds of stealing before |
233 // If we're the termination task, try 10 rounds of stealing before |
234 // setting the termination flag |
234 // setting the termination flag |
235 |
235 |
236 while(true) { |
236 while(true) { |
237 if (ParCompactionManager::steal(which, &random_seed, chunk_index)) { |
237 if (ParCompactionManager::steal(which, &random_seed, region_index)) { |
238 PSParallelCompact::fill_and_update_chunk(cm, chunk_index); |
238 PSParallelCompact::fill_and_update_region(cm, region_index); |
239 cm->drain_chunk_stacks(); |
239 cm->drain_region_stacks(); |
240 } else { |
240 } else { |
241 if (terminator()->offer_termination()) { |
241 if (terminator()->offer_termination()) { |
242 break; |
242 break; |
243 } |
243 } |
244 // Go around again. |
244 // Go around again. |
247 return; |
247 return; |
248 } |
248 } |
249 |
249 |
250 UpdateDensePrefixTask::UpdateDensePrefixTask( |
250 UpdateDensePrefixTask::UpdateDensePrefixTask( |
251 PSParallelCompact::SpaceId space_id, |
251 PSParallelCompact::SpaceId space_id, |
252 size_t chunk_index_start, |
252 size_t region_index_start, |
253 size_t chunk_index_end) : |
253 size_t region_index_end) : |
254 _space_id(space_id), _chunk_index_start(chunk_index_start), |
254 _space_id(space_id), _region_index_start(region_index_start), |
255 _chunk_index_end(chunk_index_end) |
255 _region_index_end(region_index_end) {} |
256 {} |
|
257 |
256 |
258 void UpdateDensePrefixTask::do_it(GCTaskManager* manager, uint which) { |
257 void UpdateDensePrefixTask::do_it(GCTaskManager* manager, uint which) { |
259 |
258 |
260 NOT_PRODUCT(TraceTime tm("UpdateDensePrefixTask", |
259 NOT_PRODUCT(TraceTime tm("UpdateDensePrefixTask", |
261 PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); |
260 PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); |
263 ParCompactionManager* cm = |
262 ParCompactionManager* cm = |
264 ParCompactionManager::gc_thread_compaction_manager(which); |
263 ParCompactionManager::gc_thread_compaction_manager(which); |
265 |
264 |
266 PSParallelCompact::update_and_deadwood_in_dense_prefix(cm, |
265 PSParallelCompact::update_and_deadwood_in_dense_prefix(cm, |
267 _space_id, |
266 _space_id, |
268 _chunk_index_start, |
267 _region_index_start, |
269 _chunk_index_end); |
268 _region_index_end); |
270 } |
269 } |
271 |
270 |
272 void DrainStacksCompactionTask::do_it(GCTaskManager* manager, uint which) { |
271 void DrainStacksCompactionTask::do_it(GCTaskManager* manager, uint which) { |
273 assert(Universe::heap()->is_gc_active(), "called outside gc"); |
272 assert(Universe::heap()->is_gc_active(), "called outside gc"); |
274 |
273 |
276 PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); |
275 PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty)); |
277 |
276 |
278 ParCompactionManager* cm = |
277 ParCompactionManager* cm = |
279 ParCompactionManager::gc_thread_compaction_manager(which); |
278 ParCompactionManager::gc_thread_compaction_manager(which); |
280 |
279 |
281 // Process any chunks already in the compaction managers stacks. |
280 // Process any regions already in the compaction managers stacks. |
282 cm->drain_chunk_stacks(); |
281 cm->drain_region_stacks(); |
283 } |
282 } |