740 uint worker_id,
741 double elapsed_ms,
742 double strong_roots_ms,
743 double term_ms,
744 size_t term_attempts,
745 size_t alloc_buffer_waste,
746 size_t undo_waste) const;
747 // Update object copying statistics.
748 void record_obj_copy_mem_stats();
749
750 // The g1 remembered set of the heap.
751 G1RemSet* _g1_rem_set;
752
753 // A set of cards that cover the objects for which the Rsets should be updated
754 // concurrently after the collection.
755 DirtyCardQueueSet _dirty_card_queue_set;
756
757 // The closure used to refine a single card.
758 RefineCardTableEntryClosure* _refine_cte_cl;
759
760 // A DirtyCardQueueSet that is used to hold cards that contain
761 // references into the current collection set. This is used to
762 // update the remembered sets of the regions in the collection
763 // set in the event of an evacuation failure.
764 DirtyCardQueueSet _into_cset_dirty_card_queue_set;
765
766 // After a collection pause, make the regions in the CS into free
767 // regions.
768 void free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info, const size_t* surviving_young_words);
769
770 // Abandon the current collection set without recording policy
771 // statistics or updating free lists.
772 void abandon_collection_set(HeapRegion* cs_head);
773
774 // The concurrent marker (and the thread it runs in.)
775 ConcurrentMark* _cm;
776 ConcurrentMarkThread* _cmThread;
777
778 // The concurrent refiner.
779 ConcurrentG1Refine* _cg1r;
780
781 // The parallel task queues
782 RefToScanQueueSet *_task_queues;
783
784 // True iff a evacuation has failed in the current collection.
785 bool _evacuation_failed;
934
935 // Time stamp to validate the regions recorded in the cache
936 // used by G1CollectedHeap::start_cset_region_for_worker().
937 // The heap region entry for a given worker is valid iff
938 // the associated time stamp value matches the current value
939 // of G1CollectedHeap::_gc_time_stamp.
940 uint* _worker_cset_start_region_time_stamp;
941
942 volatile bool _free_regions_coming;
943
944 public:
945
946 void set_refine_cte_cl_concurrency(bool concurrent);
947
948 RefToScanQueue *task_queue(uint i) const;
949
950 uint num_task_queues() const;
951
952 // A set of cards where updates happened during the GC
953 DirtyCardQueueSet& dirty_card_queue_set() { return _dirty_card_queue_set; }
954
955 // A DirtyCardQueueSet that is used to hold cards that contain
956 // references into the current collection set. This is used to
957 // update the remembered sets of the regions in the collection
958 // set in the event of an evacuation failure.
959 DirtyCardQueueSet& into_cset_dirty_card_queue_set()
960 { return _into_cset_dirty_card_queue_set; }
961
962 // Create a G1CollectedHeap with the specified policy.
963 // Must call the initialize method afterwards.
964 // May not return if something goes wrong.
965 G1CollectedHeap(G1CollectorPolicy* policy);
966
967 // Initialize the G1CollectedHeap to have the initial and
968 // maximum sizes and remembered and barrier sets
969 // specified by the policy object.
970 jint initialize();
971
972 virtual void stop();
973
974 // Return the (conservative) maximum heap alignment for any G1 heap
975 static size_t conservative_max_heap_alignment();
976
977 // Does operations required after initialization has been done.
978 void post_initialize();
979
980 // Initialize weak reference processing.
|
740 uint worker_id,
741 double elapsed_ms,
742 double strong_roots_ms,
743 double term_ms,
744 size_t term_attempts,
745 size_t alloc_buffer_waste,
746 size_t undo_waste) const;
747 // Update object copying statistics.
748 void record_obj_copy_mem_stats();
749
750 // The g1 remembered set of the heap.
751 G1RemSet* _g1_rem_set;
752
753 // A set of cards that cover the objects for which the Rsets should be updated
754 // concurrently after the collection.
755 DirtyCardQueueSet _dirty_card_queue_set;
756
757 // The closure used to refine a single card.
758 RefineCardTableEntryClosure* _refine_cte_cl;
759
760 // After a collection pause, make the regions in the CS into free
761 // regions.
762 void free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info, const size_t* surviving_young_words);
763
764 // Abandon the current collection set without recording policy
765 // statistics or updating free lists.
766 void abandon_collection_set(HeapRegion* cs_head);
767
768 // The concurrent marker (and the thread it runs in.)
769 ConcurrentMark* _cm;
770 ConcurrentMarkThread* _cmThread;
771
772 // The concurrent refiner.
773 ConcurrentG1Refine* _cg1r;
774
775 // The parallel task queues
776 RefToScanQueueSet *_task_queues;
777
778 // True iff a evacuation has failed in the current collection.
779 bool _evacuation_failed;
928
929 // Time stamp to validate the regions recorded in the cache
930 // used by G1CollectedHeap::start_cset_region_for_worker().
931 // The heap region entry for a given worker is valid iff
932 // the associated time stamp value matches the current value
933 // of G1CollectedHeap::_gc_time_stamp.
934 uint* _worker_cset_start_region_time_stamp;
935
936 volatile bool _free_regions_coming;
937
938 public:
939
940 void set_refine_cte_cl_concurrency(bool concurrent);
941
942 RefToScanQueue *task_queue(uint i) const;
943
944 uint num_task_queues() const;
945
946 // A set of cards where updates happened during the GC
947 DirtyCardQueueSet& dirty_card_queue_set() { return _dirty_card_queue_set; }
948
949 // Create a G1CollectedHeap with the specified policy.
950 // Must call the initialize method afterwards.
951 // May not return if something goes wrong.
952 G1CollectedHeap(G1CollectorPolicy* policy);
953
954 // Initialize the G1CollectedHeap to have the initial and
955 // maximum sizes and remembered and barrier sets
956 // specified by the policy object.
957 jint initialize();
958
959 virtual void stop();
960
961 // Return the (conservative) maximum heap alignment for any G1 heap
962 static size_t conservative_max_heap_alignment();
963
964 // Does operations required after initialization has been done.
965 void post_initialize();
966
967 // Initialize weak reference processing.
|