< prev index next >

src/hotspot/share/gc/z/zDriver.cpp

concurrent root iterator

318     // Update statistics                                                                                                             
319     ZStatCycle::at_end(boost_factor);                                                                                                
320 
321     // Update data used by soft reference policy                                                                                     
322     Universe::update_heap_info_at_gc();                                                                                              
323   }                                                                                                                                  
324 };                                                                                                                                   
325 
326 void ZDriver::run_gc_cycle(GCCause::Cause cause) {                                                                                   
327   ZDriverCycleScope scope(cause);                                                                                                    
328 
329   // Phase 1: Pause Mark Start                                                                                                       
330   {                                                                                                                                  
331     ZMarkStartClosure cl;                                                                                                            
332     vm_operation(&cl);                                                                                                               
333   }                                                                                                                                  
334 
335   // Phase 2: Concurrent Mark                                                                                                        
336   {                                                                                                                                  
337     ZStatTimer timer(ZPhaseConcurrentMark);                                                                                          
                                                                                                                                     
338     ZHeap::heap()->mark();                                                                                                           
339   }                                                                                                                                  
340 
341   // Phase 3: Pause Mark End                                                                                                         
342   {                                                                                                                                  
343     ZMarkEndClosure cl;                                                                                                              
344     while (!vm_operation(&cl)) {                                                                                                     
345       // Phase 3.5: Concurrent Mark Continue                                                                                         
346       ZStatTimer timer(ZPhaseConcurrentMarkContinue);                                                                                
347       ZHeap::heap()->mark();                                                                                                         
348     }                                                                                                                                
349   }                                                                                                                                  
350 
351   // Phase 4: Concurrent Process Non-Strong References                                                                               
352   {                                                                                                                                  
353     ZStatTimer timer(ZPhaseConcurrentProcessNonStrongReferences);                                                                    
354     ZHeap::heap()->process_non_strong_references();                                                                                  
355   }                                                                                                                                  
356 

318     // Update statistics
319     ZStatCycle::at_end(boost_factor);
320 
321     // Update data used by soft reference policy
322     Universe::update_heap_info_at_gc();
323   }
324 };
325 
326 void ZDriver::run_gc_cycle(GCCause::Cause cause) {
327   ZDriverCycleScope scope(cause);
328 
329   // Phase 1: Pause Mark Start
330   {
331     ZMarkStartClosure cl;
332     vm_operation(&cl);
333   }
334 
335   // Phase 2: Concurrent Mark
336   {
337     ZStatTimer timer(ZPhaseConcurrentMark);
338     ZHeap::heap()->mark_concurrent_roots();
339     ZHeap::heap()->mark();
340   }
341 
342   // Phase 3: Pause Mark End
343   {
344     ZMarkEndClosure cl;
345     while (!vm_operation(&cl)) {
346       // Phase 3.5: Concurrent Mark Continue
347       ZStatTimer timer(ZPhaseConcurrentMarkContinue);
348       ZHeap::heap()->mark();
349     }
350   }
351 
352   // Phase 4: Concurrent Process Non-Strong References
353   {
354     ZStatTimer timer(ZPhaseConcurrentProcessNonStrongReferences);
355     ZHeap::heap()->process_non_strong_references();
356   }
357 
< prev index next >