< prev index next >

src/hotspot/share/gc/shenandoah/shenandoahRootProcessor.hpp

Print this page




 260   ShenandoahCodeCacheRoots<ShenandoahAllCodeRootsIterator> _code_roots;
 261 
 262 public:
 263   ShenandoahHeapIterationRootScanner();
 264 
 265   void roots_do(OopClosure* cl);
 266   void strong_roots_do(OopClosure* cl);
 267 };
 268 
 269 // Evacuate all roots at a safepoint
 270 class ShenandoahRootEvacuator : public ShenandoahRootProcessor {
 271 private:
 272   ShenandoahSerialRoots                                     _serial_roots;
 273   ShenandoahVMRoots<false /*concurrent*/>                   _vm_roots;
 274   ShenandoahClassLoaderDataRoots<false /*concurrent*/, false /*single threaded*/>
 275                                                             _cld_roots;
 276   ShenandoahThreadRoots                                     _thread_roots;
 277   ShenandoahSerialWeakRoots                                 _serial_weak_roots;
 278   ShenandoahWeakRoots<false /*concurrent*/>                 _weak_roots;
 279   ShenandoahStringDedupRoots                                _dedup_roots;
 280   ShenandoahCodeCacheRoots<ShenandoahCsetCodeRootsIterator> _code_roots;
 281   bool                                                      _include_concurrent_roots;
 282 
 283 public:
 284   ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool include_concurrent_roots);

 285 
 286   void roots_do(uint worker_id, OopClosure* oops);
 287 };
 288 
 289 // Update all roots at a safepoint
 290 class ShenandoahRootUpdater : public ShenandoahRootProcessor {
 291 private:
 292   ShenandoahSerialRoots                                     _serial_roots;
 293   ShenandoahVMRoots<false /*concurrent*/>                   _vm_roots;
 294   ShenandoahClassLoaderDataRoots<false /*concurrent*/, false /*single threaded*/>
 295                                                             _cld_roots;
 296   ShenandoahThreadRoots                                     _thread_roots;
 297   ShenandoahSerialWeakRoots                                 _serial_weak_roots;
 298   ShenandoahWeakRoots<false /*concurrent*/>                 _weak_roots;
 299   ShenandoahStringDedupRoots                                _dedup_roots;
 300   ShenandoahCodeCacheRoots<ShenandoahCsetCodeRootsIterator> _code_roots;
 301 
 302 public:
 303   ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase);
 304 
 305   template<typename IsAlive, typename KeepAlive>
 306   void roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive);
 307 
 308   void strong_roots_do(uint worker_id, OopClosure* oops_cl);
 309 };
 310 
 311 // Adjuster all roots at a safepoint during full gc
 312 class ShenandoahRootAdjuster : public ShenandoahRootProcessor {
 313 private:
 314   ShenandoahSerialRoots                                     _serial_roots;
 315   ShenandoahVMRoots<false /*concurrent*/>                   _vm_roots;
 316   ShenandoahClassLoaderDataRoots<false /*concurrent*/, false /*single threaded*/>
 317                                                             _cld_roots;
 318   ShenandoahThreadRoots                                     _thread_roots;
 319   ShenandoahSerialWeakRoots                                 _serial_weak_roots;
 320   ShenandoahWeakRoots<false /*concurrent*/>                 _weak_roots;


 260   ShenandoahCodeCacheRoots<ShenandoahAllCodeRootsIterator> _code_roots;
 261 
 262 public:
 263   ShenandoahHeapIterationRootScanner();
 264 
 265   void roots_do(OopClosure* cl);
 266   void strong_roots_do(OopClosure* cl);
 267 };
 268 
 269 // Evacuate all roots at a safepoint
 270 class ShenandoahRootEvacuator : public ShenandoahRootProcessor {
 271 private:
 272   ShenandoahSerialRoots                                     _serial_roots;
 273   ShenandoahVMRoots<false /*concurrent*/>                   _vm_roots;
 274   ShenandoahClassLoaderDataRoots<false /*concurrent*/, false /*single threaded*/>
 275                                                             _cld_roots;
 276   ShenandoahThreadRoots                                     _thread_roots;
 277   ShenandoahSerialWeakRoots                                 _serial_weak_roots;
 278   ShenandoahWeakRoots<false /*concurrent*/>                 _weak_roots;
 279   ShenandoahStringDedupRoots                                _dedup_roots;
 280   ShenandoahCodeCacheRoots<ShenandoahAllCodeRootsIterator>  _code_roots;
 281   bool                                                      _include_concurrent_roots;
 282   bool                                                      _include_concurrent_code_roots;
 283 public:
 284   ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase,
 285                           bool include_concurrent_roots, bool _include_concurrent_code_roots);
 286 
 287   void roots_do(uint worker_id, OopClosure* oops);
 288 };
 289 
 290 // Update all roots at a safepoint
 291 class ShenandoahRootUpdater : public ShenandoahRootProcessor {
 292 private:
 293   ShenandoahSerialRoots                                     _serial_roots;
 294   ShenandoahVMRoots<false /*concurrent*/>                   _vm_roots;
 295   ShenandoahClassLoaderDataRoots<false /*concurrent*/, false /*single threaded*/>
 296                                                             _cld_roots;
 297   ShenandoahThreadRoots                                     _thread_roots;
 298   ShenandoahSerialWeakRoots                                 _serial_weak_roots;
 299   ShenandoahWeakRoots<false /*concurrent*/>                 _weak_roots;
 300   ShenandoahStringDedupRoots                                _dedup_roots;
 301   ShenandoahCodeCacheRoots<ShenandoahAllCodeRootsIterator>  _code_roots;
 302 
 303 public:
 304   ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase);
 305 
 306   template<typename IsAlive, typename KeepAlive>
 307   void roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive);
 308 
 309   void strong_roots_do(uint worker_id, OopClosure* oops_cl);
 310 };
 311 
 312 // Adjuster all roots at a safepoint during full gc
 313 class ShenandoahRootAdjuster : public ShenandoahRootProcessor {
 314 private:
 315   ShenandoahSerialRoots                                     _serial_roots;
 316   ShenandoahVMRoots<false /*concurrent*/>                   _vm_roots;
 317   ShenandoahClassLoaderDataRoots<false /*concurrent*/, false /*single threaded*/>
 318                                                             _cld_roots;
 319   ShenandoahThreadRoots                                     _thread_roots;
 320   ShenandoahSerialWeakRoots                                 _serial_weak_roots;
 321   ShenandoahWeakRoots<false /*concurrent*/>                 _weak_roots;
< prev index next >