Mercurial > hg > graal-jvmci-8
comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @ 1359:23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
Summary: Make sure that two marking cycles do not overlap, i.e., a new one can only start after the concurrent marking thread finishes all its work. In the fix I piggy-back a couple of minor extra fixes: some general code reformatting for consistency (only around the code I modified), the removal of a field (G1CollectorPolicy::_should_initiate_conc_mark) which doesn't seem to be used at all (it's only set but never read), as well as moving the "is GC locker active" test earlier into the G1 pause / Full GC and using a more appropriate method for it.
Reviewed-by: johnc, jmasa, jcoomes, ysr
author | tonyp |
---|---|
date | Tue, 06 Apr 2010 10:59:45 -0400 |
parents | 56507bcd639e |
children | 1316cec51b4d |
comparison
equal
deleted
inserted
replaced
1358:72f725c5a7be | 1359:23b1b27ac76c |
---|---|
722 // Number of pauses between concurrent marking. | 722 // Number of pauses between concurrent marking. |
723 size_t _pauses_btwn_concurrent_mark; | 723 size_t _pauses_btwn_concurrent_mark; |
724 | 724 |
725 size_t _n_marks_since_last_pause; | 725 size_t _n_marks_since_last_pause; |
726 | 726 |
727 // True iff CM has been initiated. | 727 // At the end of a pause we check the heap occupancy and we decide |
728 bool _conc_mark_initiated; | 728 // whether we will start a marking cycle during the next pause. If |
729 | 729 // we decide that we want to do that, we will set this parameter to |
730 // True iff CM should be initiated | 730 // true. So, this parameter will stay true between the end of a |
731 bool _should_initiate_conc_mark; | 731 // pause and the beginning of a subsequent pause (not necessarily |
732 // the next one, see the comments on the next field) when we decide | |
733 // that we will indeed start a marking cycle and do the initial-mark | |
734 // work. | |
735 volatile bool _initiate_conc_mark_if_possible; | |
736 | |
737 // If initiate_conc_mark_if_possible() is set at the beginning of a | |
738 // pause, it is a suggestion that the pause should start a marking | |
739 // cycle by doing the initial-mark work. However, it is possible | |
740 // that the concurrent marking thread is still finishing up the | |
741 // previous marking cycle (e.g., clearing the next marking | |
742 // bitmap). If that is the case we cannot start a new cycle and | |
743 // we'll have to wait for the concurrent marking thread to finish | |
744 // what it is doing. In this case we will postpone the marking cycle | |
745 // initiation decision for the next pause. When we eventually decide | |
746 // to start a cycle, we will set _during_initial_mark_pause which | |
747 // will stay true until the end of the initial-mark pause and it's | |
748 // the condition that indicates that a pause is doing the | |
749 // initial-mark work. | |
750 volatile bool _during_initial_mark_pause; | |
751 | |
732 bool _should_revert_to_full_young_gcs; | 752 bool _should_revert_to_full_young_gcs; |
733 bool _last_full_young_gc; | 753 bool _last_full_young_gc; |
734 | 754 |
735 // This set of variables tracks the collector efficiency, in order to | 755 // This set of variables tracks the collector efficiency, in order to |
736 // determine whether we should initiate a new marking. | 756 // determine whether we should initiate a new marking. |
979 size_t collection_set_size() { return _collection_set_size; } | 999 size_t collection_set_size() { return _collection_set_size; } |
980 | 1000 |
981 // Add "hr" to the CS. | 1001 // Add "hr" to the CS. |
982 void add_to_collection_set(HeapRegion* hr); | 1002 void add_to_collection_set(HeapRegion* hr); |
983 | 1003 |
984 bool should_initiate_conc_mark() { return _should_initiate_conc_mark; } | 1004 bool initiate_conc_mark_if_possible() { return _initiate_conc_mark_if_possible; } |
985 void set_should_initiate_conc_mark() { _should_initiate_conc_mark = true; } | 1005 void set_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = true; } |
986 void unset_should_initiate_conc_mark(){ _should_initiate_conc_mark = false; } | 1006 void clear_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = false; } |
1007 | |
1008 bool during_initial_mark_pause() { return _during_initial_mark_pause; } | |
1009 void set_during_initial_mark_pause() { _during_initial_mark_pause = true; } | |
1010 void clear_during_initial_mark_pause(){ _during_initial_mark_pause = false; } | |
1011 | |
1012 // This is called at the very beginning of an evacuation pause (it | |
1013 // has to be the first thing that the pause does). If | |
1014 // initiate_conc_mark_if_possible() is true, and the concurrent | |
1015 // marking thread has completed its work during the previous cycle, | |
1016 // it will set during_initial_mark_pause() to so that the pause does | |
1017 // the initial-mark work and start a marking cycle. | |
1018 void decide_on_conc_mark_initiation(); | |
987 | 1019 |
988 // If an expansion would be appropriate, because recent GC overhead had | 1020 // If an expansion would be appropriate, because recent GC overhead had |
989 // exceeded the desired limit, return an amount to expand by. | 1021 // exceeded the desired limit, return an amount to expand by. |
990 virtual size_t expansion_amount(); | 1022 virtual size_t expansion_amount(); |
991 | 1023 |