< prev index next >

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

Print this page




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

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


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