440 // ---------- GC subsystems
441 //
442 private:
443 ShenandoahControlThread* _control_thread;
444 ShenandoahCollectorPolicy* _shenandoah_policy;
445 ShenandoahMode* _gc_mode;
446 ShenandoahHeuristics* _heuristics;
447 ShenandoahFreeSet* _free_set;
448 ShenandoahConcurrentMark* _scm;
449 ShenandoahMarkCompact* _full_gc;
450 ShenandoahPacer* _pacer;
451 ShenandoahVerifier* _verifier;
452
453 ShenandoahPhaseTimings* _phase_timings;
454
455 ShenandoahControlThread* control_thread() { return _control_thread; }
456 ShenandoahMarkCompact* full_gc() { return _full_gc; }
457
458 public:
459 ShenandoahCollectorPolicy* shenandoah_policy() const { return _shenandoah_policy; }
460 ShenandoahHeuristics* heuristics() const { return _heuristics; }
461 ShenandoahFreeSet* free_set() const { return _free_set; }
462 ShenandoahConcurrentMark* concurrent_mark() { return _scm; }
463 ShenandoahPacer* pacer() const { return _pacer; }
464
465 ShenandoahPhaseTimings* phase_timings() const { return _phase_timings; }
466
467 ShenandoahVerifier* verifier();
468
469 // ---------- VM subsystem bindings
470 //
471 private:
472 ShenandoahMonitoringSupport* _monitoring_support;
473 MemoryPool* _memory_pool;
474 GCMemoryManager _stw_memory_manager;
475 GCMemoryManager _cycle_memory_manager;
476 ConcurrentGCTimer* _gc_timer;
477 SoftRefPolicy _soft_ref_policy;
478
479 // For exporting to SA
480 int _log_min_obj_alignment_in_bytes;
481 public:
482 ShenandoahMonitoringSupport* monitoring_support() { return _monitoring_support; }
483 GCMemoryManager* cycle_memory_manager() { return &_cycle_memory_manager; }
484 GCMemoryManager* stw_memory_manager() { return &_stw_memory_manager; }
485 SoftRefPolicy* soft_ref_policy() { return &_soft_ref_policy; }
486
487 GrowableArray<GCMemoryManager*> memory_managers();
488 GrowableArray<MemoryPool*> memory_pools();
489 MemoryUsage memory_usage();
490 GCTracer* tracer();
491 ConcurrentGCTimer* gc_timer() const;
492
493 // ---------- Reference processing
494 //
495 private:
496 AlwaysTrueClosure _subject_to_discovery;
497 ReferenceProcessor* _ref_processor;
498 ShenandoahSharedFlag _process_references;
499
500 void ref_processing_init();
501
502 public:
503 ReferenceProcessor* ref_processor() { return _ref_processor; }
504 void set_process_references(bool pr);
505 bool process_references() const;
506
507 // ---------- Class Unloading
508 //
509 private:
510 ShenandoahSharedFlag _unload_classes;
511 ShenandoahUnload _unloader;
512
513 public:
514 void set_unload_classes(bool uc);
515 bool unload_classes() const;
516
517 // Perform STW class unloading and weak root cleaning
518 void parallel_cleaning(bool full_gc);
519
520 private:
521 void stw_unload_classes(bool full_gc);
522 void stw_process_weak_roots(bool full_gc);
523
|
440 // ---------- GC subsystems
441 //
442 private:
443 ShenandoahControlThread* _control_thread;
444 ShenandoahCollectorPolicy* _shenandoah_policy;
445 ShenandoahMode* _gc_mode;
446 ShenandoahHeuristics* _heuristics;
447 ShenandoahFreeSet* _free_set;
448 ShenandoahConcurrentMark* _scm;
449 ShenandoahMarkCompact* _full_gc;
450 ShenandoahPacer* _pacer;
451 ShenandoahVerifier* _verifier;
452
453 ShenandoahPhaseTimings* _phase_timings;
454
455 ShenandoahControlThread* control_thread() { return _control_thread; }
456 ShenandoahMarkCompact* full_gc() { return _full_gc; }
457
458 public:
459 ShenandoahCollectorPolicy* shenandoah_policy() const { return _shenandoah_policy; }
460 ShenandoahMode* mode() const { return _gc_mode; }
461 ShenandoahHeuristics* heuristics() const { return _heuristics; }
462 ShenandoahFreeSet* free_set() const { return _free_set; }
463 ShenandoahConcurrentMark* concurrent_mark() { return _scm; }
464 ShenandoahPacer* pacer() const { return _pacer; }
465
466 ShenandoahPhaseTimings* phase_timings() const { return _phase_timings; }
467
468 ShenandoahVerifier* verifier();
469
470 // ---------- VM subsystem bindings
471 //
472 private:
473 ShenandoahMonitoringSupport* _monitoring_support;
474 MemoryPool* _memory_pool;
475 GCMemoryManager _stw_memory_manager;
476 GCMemoryManager _cycle_memory_manager;
477 ConcurrentGCTimer* _gc_timer;
478 SoftRefPolicy _soft_ref_policy;
479
480 // For exporting to SA
481 int _log_min_obj_alignment_in_bytes;
482 public:
483 ShenandoahMonitoringSupport* monitoring_support() { return _monitoring_support; }
484 GCMemoryManager* cycle_memory_manager() { return &_cycle_memory_manager; }
485 GCMemoryManager* stw_memory_manager() { return &_stw_memory_manager; }
486 SoftRefPolicy* soft_ref_policy() { return &_soft_ref_policy; }
487
488 GrowableArray<GCMemoryManager*> memory_managers();
489 GrowableArray<MemoryPool*> memory_pools();
490 MemoryUsage memory_usage();
491 GCTracer* tracer();
492 ConcurrentGCTimer* gc_timer() const;
493
494 // ---------- Reference processing
495 //
496 private:
497 AlwaysTrueClosure _subject_to_discovery;
498 ReferenceProcessor* _ref_processor;
499 ShenandoahSharedFlag _process_references;
500 bool _ref_proc_mt_discovery;
501 bool _ref_proc_mt_processing;
502
503 void ref_processing_init();
504
505 public:
506 ReferenceProcessor* ref_processor() { return _ref_processor; }
507 bool ref_processor_mt_discovery() { return _ref_proc_mt_discovery; }
508 bool ref_processor_mt_processing() { return _ref_proc_mt_processing; }
509 void set_process_references(bool pr);
510 bool process_references() const;
511
512 // ---------- Class Unloading
513 //
514 private:
515 ShenandoahSharedFlag _unload_classes;
516 ShenandoahUnload _unloader;
517
518 public:
519 void set_unload_classes(bool uc);
520 bool unload_classes() const;
521
522 // Perform STW class unloading and weak root cleaning
523 void parallel_cleaning(bool full_gc);
524
525 private:
526 void stw_unload_classes(bool full_gc);
527 void stw_process_weak_roots(bool full_gc);
528
|