46 #include "utilities/stack.hpp"
47
48 // A "G1CollectedHeap" is an implementation of a java heap for HotSpot.
49 // It uses the "Garbage First" heap organization and algorithm, which
50 // may combine concurrent marking with parallel, incremental compaction of
51 // heap subsets that will yield large amounts of garbage.
52
53 // Forward declarations
54 class HeapRegion;
55 class HRRSCleanupTask;
56 class GenerationSpec;
57 class OopsInHeapRegionClosure;
58 class G1KlassScanClosure;
59 class ObjectClosure;
60 class SpaceClosure;
61 class CompactibleSpaceClosure;
62 class Space;
63 class G1CollectorPolicy;
64 class GenRemSet;
65 class G1RemSet;
66 class G1PhaseTimeTracker;
67 class HeapRegionRemSetIterator;
68 class ConcurrentMark;
69 class ConcurrentMarkThread;
70 class ConcurrentG1Refine;
71 class ConcurrentGCTimer;
72 class GenerationCounters;
73 class STWGCTimer;
74 class G1NewTracer;
75 class G1OldTracer;
76 class EvacuationFailedInfo;
77 class nmethod;
78 class Ticks;
79
80 typedef OverflowTaskQueue<StarTask, mtGC> RefToScanQueue;
81 typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
82
83 typedef int RegionIdx_t; // needs to hold [ 0..max_regions() )
84 typedef int CardIdx_t; // needs to hold [ 0..CardsPerRegion )
85
86 class YoungList : public CHeapObj<mtGC> {
780
781 // Abandon the current collection set without recording policy
782 // statistics or updating free lists.
783 void abandon_collection_set(HeapRegion* cs_head);
784
785 // Applies "scan_non_heap_roots" to roots outside the heap,
786 // "scan_rs" to roots inside the heap (having done "set_region" to
787 // indicate the region in which the root resides),
788 // and does "scan_metadata" If "scan_rs" is
789 // NULL, then this step is skipped. The "worker_i"
790 // param is for use with parallel roots processing, and should be
791 // the "i" of the calling parallel worker thread's work(i) function.
792 // In the sequential case this param will be ignored.
793 void g1_process_roots(OopClosure* scan_non_heap_roots,
794 OopClosure* scan_non_heap_weak_roots,
795 G1ParPushHeapRSClosure* scan_rs,
796 CLDClosure* scan_strong_clds,
797 CLDClosure* scan_weak_clds,
798 CodeBlobClosure* scan_strong_code,
799 uint worker_i,
800 GCPhaseTimeTracker* phase_times);
801
802 // The concurrent marker (and the thread it runs in.)
803 ConcurrentMark* _cm;
804 ConcurrentMarkThread* _cmThread;
805 bool _mark_in_progress;
806
807 // The concurrent refiner.
808 ConcurrentG1Refine* _cg1r;
809
810 // The parallel task queues
811 RefToScanQueueSet *_task_queues;
812
813 // True iff a evacuation has failed in the current collection.
814 bool _evacuation_failed;
815
816 EvacuationFailedInfo* _evacuation_failed_info_array;
817
818 // Failed evacuations cause some logical from-space objects to have
819 // forwarding pointers to themselves. Reset them.
820 void remove_self_forwarding_pointers();
|
46 #include "utilities/stack.hpp"
47
48 // A "G1CollectedHeap" is an implementation of a java heap for HotSpot.
49 // It uses the "Garbage First" heap organization and algorithm, which
50 // may combine concurrent marking with parallel, incremental compaction of
51 // heap subsets that will yield large amounts of garbage.
52
53 // Forward declarations
54 class HeapRegion;
55 class HRRSCleanupTask;
56 class GenerationSpec;
57 class OopsInHeapRegionClosure;
58 class G1KlassScanClosure;
59 class ObjectClosure;
60 class SpaceClosure;
61 class CompactibleSpaceClosure;
62 class Space;
63 class G1CollectorPolicy;
64 class GenRemSet;
65 class G1RemSet;
66 class HeapRegionRemSetIterator;
67 class ConcurrentMark;
68 class ConcurrentMarkThread;
69 class ConcurrentG1Refine;
70 class ConcurrentGCTimer;
71 class GenerationCounters;
72 class STWGCTimer;
73 class G1NewTracer;
74 class G1OldTracer;
75 class EvacuationFailedInfo;
76 class nmethod;
77 class Ticks;
78
79 typedef OverflowTaskQueue<StarTask, mtGC> RefToScanQueue;
80 typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
81
82 typedef int RegionIdx_t; // needs to hold [ 0..max_regions() )
83 typedef int CardIdx_t; // needs to hold [ 0..CardsPerRegion )
84
85 class YoungList : public CHeapObj<mtGC> {
779
780 // Abandon the current collection set without recording policy
781 // statistics or updating free lists.
782 void abandon_collection_set(HeapRegion* cs_head);
783
784 // Applies "scan_non_heap_roots" to roots outside the heap,
785 // "scan_rs" to roots inside the heap (having done "set_region" to
786 // indicate the region in which the root resides),
787 // and does "scan_metadata" If "scan_rs" is
788 // NULL, then this step is skipped. The "worker_i"
789 // param is for use with parallel roots processing, and should be
790 // the "i" of the calling parallel worker thread's work(i) function.
791 // In the sequential case this param will be ignored.
792 void g1_process_roots(OopClosure* scan_non_heap_roots,
793 OopClosure* scan_non_heap_weak_roots,
794 G1ParPushHeapRSClosure* scan_rs,
795 CLDClosure* scan_strong_clds,
796 CLDClosure* scan_weak_clds,
797 CodeBlobClosure* scan_strong_code,
798 uint worker_i,
799 PhaseTimeData* phase_times);
800
801 // The concurrent marker (and the thread it runs in.)
802 ConcurrentMark* _cm;
803 ConcurrentMarkThread* _cmThread;
804 bool _mark_in_progress;
805
806 // The concurrent refiner.
807 ConcurrentG1Refine* _cg1r;
808
809 // The parallel task queues
810 RefToScanQueueSet *_task_queues;
811
812 // True iff a evacuation has failed in the current collection.
813 bool _evacuation_failed;
814
815 EvacuationFailedInfo* _evacuation_failed_info_array;
816
817 // Failed evacuations cause some logical from-space objects to have
818 // forwarding pointers to themselves. Reset them.
819 void remove_self_forwarding_pointers();
|