< prev index next >

src/share/vm/gc/g1/g1CollectedHeap.hpp

Print this page
rev 8813 : imported patch 8003237-no-wait-for-free-list
rev 8814 : imported patch jon-fast-evac-failure
rev 8816 : [mq]: 8133470-fix-plab-inline
rev 8818 : imported patch 8073013-add-detailed-information-about-plab-memory-usage
rev 8819 : imported patch jon-review-statistics
rev 8822 : imported patch move-jfr-event-to-extra-cr
rev 8823 : imported patch 8133530-add-jfr-event-for-evacuation


 774   // Heap_lock when we enter this method, we will pass the
 775   // gc_count_before (i.e., total_collections()) as a parameter since
 776   // it has to be read while holding the Heap_lock. Currently, both
 777   // methods that call do_collection_pause() release the Heap_lock
 778   // before the call, so it's easy to read gc_count_before just before.
 779   HeapWord* do_collection_pause(size_t         word_size,
 780                                 uint           gc_count_before,
 781                                 bool*          succeeded,
 782                                 GCCause::Cause gc_cause);
 783 
 784   void wait_for_root_region_scanning();
 785 
 786   // The guts of the incremental collection pause, executed by the vm
 787   // thread. It returns false if it is unable to do the collection due
 788   // to the GC locker being active, true otherwise
 789   bool do_collection_pause_at_safepoint(double target_pause_time_ms);
 790 
 791   // Actually do the work of evacuating the collection set.
 792   void evacuate_collection_set(EvacuationInfo& evacuation_info);
 793   



 794   // The g1 remembered set of the heap.
 795   G1RemSet* _g1_rem_set;
 796 
 797   // A set of cards that cover the objects for which the Rsets should be updated
 798   // concurrently after the collection.
 799   DirtyCardQueueSet _dirty_card_queue_set;
 800 
 801   // The closure used to refine a single card.
 802   RefineCardTableEntryClosure* _refine_cte_cl;
 803 
 804   // A DirtyCardQueueSet that is used to hold cards that contain
 805   // references into the current collection set. This is used to
 806   // update the remembered sets of the regions in the collection
 807   // set in the event of an evacuation failure.
 808   DirtyCardQueueSet _into_cset_dirty_card_queue_set;
 809 
 810   // After a collection pause, make the regions in the CS into free
 811   // regions.
 812   void free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info);
 813 


1549   // vo == UseMarkWord, which is to verify the marking during a
1550   // full GC.
1551   void verify(bool silent, VerifyOption vo);
1552 
1553   // Override; it uses the "prev" marking information
1554   virtual void verify(bool silent);
1555 
1556   // The methods below are here for convenience and dispatch the
1557   // appropriate method depending on value of the given VerifyOption
1558   // parameter. The values for that parameter, and their meanings,
1559   // are the same as those above.
1560 
1561   bool is_obj_dead_cond(const oop obj,
1562                         const HeapRegion* hr,
1563                         const VerifyOption vo) const;
1564 
1565   bool is_obj_dead_cond(const oop obj,
1566                         const VerifyOption vo) const;
1567 
1568   G1HeapSummary create_g1_heap_summary();

1569 
1570   // Printing
1571 
1572   virtual void print_on(outputStream* st) const;
1573   virtual void print_extended_on(outputStream* st) const;
1574   virtual void print_on_error(outputStream* st) const;
1575 
1576   virtual void print_gc_threads_on(outputStream* st) const;
1577   virtual void gc_threads_do(ThreadClosure* tc) const;
1578 
1579   // Override
1580   void print_tracing_info() const;
1581 
1582   // The following two methods are helpful for debugging RSet issues.
1583   void print_cset_rsets() PRODUCT_RETURN;
1584   void print_all_rsets() PRODUCT_RETURN;
1585 
1586 public:
1587   size_t pending_card_num();
1588   size_t cards_scanned();


 774   // Heap_lock when we enter this method, we will pass the
 775   // gc_count_before (i.e., total_collections()) as a parameter since
 776   // it has to be read while holding the Heap_lock. Currently, both
 777   // methods that call do_collection_pause() release the Heap_lock
 778   // before the call, so it's easy to read gc_count_before just before.
 779   HeapWord* do_collection_pause(size_t         word_size,
 780                                 uint           gc_count_before,
 781                                 bool*          succeeded,
 782                                 GCCause::Cause gc_cause);
 783 
 784   void wait_for_root_region_scanning();
 785 
 786   // The guts of the incremental collection pause, executed by the vm
 787   // thread. It returns false if it is unable to do the collection due
 788   // to the GC locker being active, true otherwise
 789   bool do_collection_pause_at_safepoint(double target_pause_time_ms);
 790 
 791   // Actually do the work of evacuating the collection set.
 792   void evacuate_collection_set(EvacuationInfo& evacuation_info);
 793 
 794   // Update object copying statistics.
 795   void record_obj_copy_mem_stats();
 796   
 797   // The g1 remembered set of the heap.
 798   G1RemSet* _g1_rem_set;
 799 
 800   // A set of cards that cover the objects for which the Rsets should be updated
 801   // concurrently after the collection.
 802   DirtyCardQueueSet _dirty_card_queue_set;
 803 
 804   // The closure used to refine a single card.
 805   RefineCardTableEntryClosure* _refine_cte_cl;
 806 
 807   // A DirtyCardQueueSet that is used to hold cards that contain
 808   // references into the current collection set. This is used to
 809   // update the remembered sets of the regions in the collection
 810   // set in the event of an evacuation failure.
 811   DirtyCardQueueSet _into_cset_dirty_card_queue_set;
 812 
 813   // After a collection pause, make the regions in the CS into free
 814   // regions.
 815   void free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info);
 816 


1552   // vo == UseMarkWord, which is to verify the marking during a
1553   // full GC.
1554   void verify(bool silent, VerifyOption vo);
1555 
1556   // Override; it uses the "prev" marking information
1557   virtual void verify(bool silent);
1558 
1559   // The methods below are here for convenience and dispatch the
1560   // appropriate method depending on value of the given VerifyOption
1561   // parameter. The values for that parameter, and their meanings,
1562   // are the same as those above.
1563 
1564   bool is_obj_dead_cond(const oop obj,
1565                         const HeapRegion* hr,
1566                         const VerifyOption vo) const;
1567 
1568   bool is_obj_dead_cond(const oop obj,
1569                         const VerifyOption vo) const;
1570 
1571   G1HeapSummary create_g1_heap_summary();
1572   G1EvacSummary create_g1_evac_summary(G1EvacStats* stats);
1573 
1574   // Printing
1575 
1576   virtual void print_on(outputStream* st) const;
1577   virtual void print_extended_on(outputStream* st) const;
1578   virtual void print_on_error(outputStream* st) const;
1579 
1580   virtual void print_gc_threads_on(outputStream* st) const;
1581   virtual void gc_threads_do(ThreadClosure* tc) const;
1582 
1583   // Override
1584   void print_tracing_info() const;
1585 
1586   // The following two methods are helpful for debugging RSet issues.
1587   void print_cset_rsets() PRODUCT_RETURN;
1588   void print_all_rsets() PRODUCT_RETURN;
1589 
1590 public:
1591   size_t pending_card_num();
1592   size_t cards_scanned();
< prev index next >