--- old/src/hotspot/share/gc/g1/g1CollectionSet.hpp 2019-03-13 14:03:00.215005842 +0100 +++ new/src/hotspot/share/gc/g1/g1CollectionSet.hpp 2019-03-13 14:03:00.004000112 +0100 @@ -38,11 +38,32 @@ class HeapRegion; class HeapRegionClosure; +// The collection set. +// +// The collection set is built incrementally: it starts off with the set of +// survivor regions, and at mutator time G1 adds retired up eden regions to it. +// +// For non-mixed collections this is all the collection set consists of and its +// regions are evacuated in one pass. +// +// For mixed collections we not only determine a few old gen regions for an initial +// collection set, but also a set of optional collection set regions from the +// collection set candidates. +// +// After evacuating the initial collection set, G1 incrementally selects more +// regions from the optional collection set regions as time prediction permit. +// +// Support for incremental building is implemented by keeping an index into the +// collection set set; during evacuation only the part from that index to the +// end is used for evacuation. +// +// This results in having a single complete collection set of the evacuation phases +// for cleaning up. class G1CollectionSet { G1CollectedHeap* _g1h; G1Policy* _policy; - // All old gen collection set candidate regions for the current mixed gc phase. + // All old gen collection set candidate regions for the current mixed phase. G1CollectionSetCandidates* _candidates; uint _eden_region_length; @@ -51,7 +72,7 @@ // The actual collection set as a set of region indices. // All entries in _collection_set_regions below _collection_set_cur_length are - // assumed to be valid entries. + // assumed to be part of the collection set. // We assume that at any time there is at most only one writer and (one or more) // concurrent readers. This means we are good with using storestore and loadload // barriers on the writer and reader respectively only. @@ -59,31 +80,33 @@ volatile size_t _collection_set_cur_length; size_t _collection_set_max_length; - // When doing mixed collections we can add old regions to the collection, which - // can be collected if there is enough time. We call these optional regions and - // the pointer to these regions are stored in the array below. - HeapRegion** _optional_regions; - uint _optional_region_length; - uint _optional_region_max_length; + // When doing mixed collections we can add old regions to the collection set, which + // will be collected only if there is enough time. We call these optional regions. + // This member records the current number of regions that are of that type that + // correspond to the first x entries in the collection set candidates. + uint _num_optional_regions; // The number of bytes in the collection set before the pause. Set from // the incrementally built collection set at the start of an evacuation - // pause, and incremented in finalize_old_part() when adding old regions - // (if any) to the collection set. + // pause, and updated as more regions are added to the collection set. size_t _bytes_used_before; + // The number of cards in the remembered set in the collection set. Set from + // the incrementally built collection set at the start of an evacuation + // pause, and updated as more regions are added to the collection set. size_t _recorded_rs_lengths; - // The associated information that is maintained while the incremental - // collection set is being built with young regions. Used to populate - // the recorded info for the evacuation pause. - enum CSetBuildType { Active, // We are actively building the collection set Inactive // We are not actively building the collection set }; CSetBuildType _inc_build_state; + size_t _inc_part_start; + + // The associated information that is maintained while the incremental + // collection set is being built with *young* regions. Used to populate + // the recorded info for the evacuation pause. // The number of bytes in the incrementally built collection set. // Used to set _collection_set_bytes_used_before at the start of @@ -117,10 +140,28 @@ G1GCPhaseTimes* phase_times(); void verify_young_cset_indices() const NOT_DEBUG_RETURN; - void add_as_optional(HeapRegion* hr); - void add_as_old(HeapRegion* hr); - bool optional_is_full(); + double predict_region_elapsed_time_ms(HeapRegion* hr); + + // Update the incremental collection set information when adding a region. + void add_young_region_common(HeapRegion* hr); + + // Add old region "hr" to the collection set. + void add_old_region(HeapRegion* hr); + + // Add old region "hr" to optional collection set. + void add_optional_region(HeapRegion* hr); + + void move_candidates_to_collection_set(uint num_regions); + + // Choose a new collection set. Marks the chosen regions as being + // "in_collection_set". + double finalize_young_part(double target_pause_time_ms, G1SurvivorRegions* survivors); + // Perform any final calculations on the incremental collection set fields + // before we can use them. + void finalize_young_increment(); + + void finalize_old_part(double time_remaining_ms); public: G1CollectionSet(G1CollectedHeap* g1h, G1Policy* policy); ~G1CollectionSet(); @@ -151,32 +192,29 @@ uint eden_region_length() const { return _eden_region_length; } uint survivor_region_length() const { return _survivor_region_length; } uint old_region_length() const { return _old_region_length; } - uint optional_region_length() const { return _optional_region_length; } + uint optional_region_length() const { return _num_optional_regions; } + + // Reset the contents of the collection set. + void clear(); // Incremental collection set support // Initialize incremental collection set info. void start_incremental_building(); + // Start a new collection set increment. + void update_incremental_marker() { _inc_build_state = Active; _inc_part_start = _collection_set_cur_length; } + // Stop adding regions to the current collection set increment. + void stop_incremental_building() { _inc_build_state = Inactive; } - // Perform any final calculations on the incremental collection set fields - // before we can use them. - void finalize_incremental_building(); - - // Reset the contents of the collection set. - void clear(); + // Iterate over the current collection set increment applying the given HeapRegionClosure + // from a starting position determined by the given worker id. + void iterate_incremental_part_from(HeapRegionClosure* cl, uint worker_id, uint total_workers) const; - // Iterate over the collection set, applying the given HeapRegionClosure on all of them. - // If may_be_aborted is true, iteration may be aborted using the return value of the - // called closure method. + // Iterate over the entire collection set (all increments calculated so far), applying + // the given HeapRegionClosure on all of them. void iterate(HeapRegionClosure* cl) const; - // Iterate over the collection set, applying the given HeapRegionClosure on all of them, - // trying to optimally spread out starting position of total_workers workers given the - // caller's worker_id. - void iterate_from(HeapRegionClosure* cl, uint worker_id, uint total_workers) const; - - // Stop adding regions to the incremental collection set. - void stop_incremental_building() { _inc_build_state = Inactive; } + void iterate_optional(HeapRegionClosure* cl) const; size_t recorded_rs_lengths() { return _recorded_rs_lengths; } @@ -188,16 +226,14 @@ _bytes_used_before = 0; } - // Choose a new collection set. Marks the chosen regions as being - // "in_collection_set". - double finalize_young_part(double target_pause_time_ms, G1SurvivorRegions* survivors); - void finalize_old_part(double time_remaining_ms); - - // Add old region "hr" to the collection set. - void add_old_region(HeapRegion* hr); - - // Add old region "hr" to optional collection set. - void add_optional_region(HeapRegion* hr); + // Finalize the initial (first) collection set consisting of all young regions and a + // few old gen regions. + void finalize_initial_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor); + // Finalize the next collection set from the set of available optional old gen regions. + bool finalize_optional_for_evacuation(double remaining_pause_time); + // Abandon (clean up) optional collection set regions that were not evacuated in this + // pause. + void abandon_optional_collection_set(G1ParScanThreadStateSet* pss); // Update information about hr in the aggregated information for // the incrementally built collection set. @@ -214,73 +250,6 @@ void print(outputStream* st); #endif // !PRODUCT - - double predict_region_elapsed_time_ms(HeapRegion* hr); - - void clear_optional_region(const HeapRegion* hr); - - HeapRegion* optional_region_at(uint i) const { - assert(_optional_regions != NULL, "Not yet initialized"); - assert(i < _optional_region_length, "index %u out of bounds (%u)", i, _optional_region_length); - return _optional_regions[i]; - } - - HeapRegion* remove_last_optional_region() { - assert(_optional_regions != NULL, "Not yet initialized"); - assert(_optional_region_length != 0, "No region to remove"); - _optional_region_length--; - HeapRegion* removed = _optional_regions[_optional_region_length]; - _optional_regions[_optional_region_length] = NULL; - return removed; - } - -private: - // Update the incremental collection set information when adding a region. - void add_young_region_common(HeapRegion* hr); -}; - -// Helper class to manage the optional regions in a Mixed collection. -class G1OptionalCSet : public StackObj { -private: - G1CollectionSet* _cset; - G1ParScanThreadStateSet* _pset; - uint _current_index; - uint _current_limit; - bool _prepare_failed; - bool _evacuation_failed; - - void prepare_to_evacuate_optional_region(HeapRegion* hr); - -public: - static const uint InvalidCSetIndex = UINT_MAX; - - G1OptionalCSet(G1CollectionSet* cset, G1ParScanThreadStateSet* pset) : - _cset(cset), - _pset(pset), - _current_index(0), - _current_limit(0), - _prepare_failed(false), - _evacuation_failed(false) { } - // The destructor returns regions to the collection set candidates set and - // frees the optional structure in the collection set. - ~G1OptionalCSet(); - - uint current_index() { return _current_index; } - uint current_limit() { return _current_limit; } - - uint size(); - bool is_empty(); - - HeapRegion* region_at(uint index); - - // Prepare a set of regions for optional evacuation. - void prepare_evacuation(double time_left_ms); - bool prepare_failed(); - - // Complete the evacuation of the previously prepared - // regions by updating their state and check for failures. - void complete_evacuation(); - bool evacuation_failed(); }; #endif // SHARE_GC_G1_G1COLLECTIONSET_HPP