1 /* 2 * Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_GC_G1_G1REMSET_HPP 26 #define SHARE_GC_G1_G1REMSET_HPP 27 28 #include "gc/g1/g1CardTable.hpp" 29 #include "gc/g1/g1OopClosures.hpp" 30 #include "gc/g1/g1GCPhaseTimes.hpp" 31 #include "gc/g1/g1RemSetSummary.hpp" 32 #include "gc/g1/heapRegion.hpp" 33 #include "memory/allocation.hpp" 34 #include "memory/iterator.hpp" 35 #include "utilities/ticks.hpp" 36 37 // A G1RemSet provides ways of iterating over pointers into a selected 38 // collection set. 39 40 class BitMap; 41 class CardTableBarrierSet; 42 class G1BlockOffsetTable; 43 class CodeBlobClosure; 44 class G1CollectedHeap; 45 class G1CMBitMap; 46 class G1HotCardCache; 47 class G1RemSetScanState; 48 class G1ParScanThreadState; 49 class G1ParScanThreadStateSet; 50 class G1Policy; 51 class G1ScanCardClosure; 52 class HeapRegionClaimer; 53 54 // A G1RemSet in which each heap region has a rem set that records the 55 // external heap references into it. Uses a mod ref bs to track updates, 56 // so that they can be used to update the individual region remsets. 57 class G1RemSet: public CHeapObj<mtGC> { 58 private: 59 G1RemSetScanState* _scan_state; 60 61 G1RemSetSummary _prev_period_summary; 62 63 G1CollectedHeap* _g1h; 64 65 G1CardTable* _ct; 66 G1Policy* _g1p; 67 G1HotCardCache* _hot_card_cache; 68 69 void print_merge_heap_roots_stats(); 70 public: 71 72 typedef CardTable::CardValue CardValue; 73 // Gives an approximation on how many threads can be expected to add records to 74 // a remembered set in parallel. This can be used for sizing data structures to 75 // decrease performance losses due to data structure sharing. 76 // Examples for quantities that influence this value are the maximum number of 77 // mutator threads, maximum number of concurrent refinement or GC threads. 78 static uint num_par_rem_sets(); 79 80 // Initialize data that depends on the heap size being known. 81 void initialize(size_t capacity, uint max_regions); 82 83 G1RemSet(G1CollectedHeap* g1h, 84 G1CardTable* ct, 85 G1HotCardCache* hot_card_cache); 86 ~G1RemSet(); 87 88 // Scan all cards in the non-collection set regions that potentially contain 89 // references into the current whole collection set. 90 void scan_heap_roots(G1ParScanThreadState* pss, 91 uint worker_id, 92 G1GCPhaseTimes::GCParPhases scan_phase, 93 G1GCPhaseTimes::GCParPhases objcopy_phase); 94 95 // Merge cards from various sources (remembered sets, hot card cache, log buffers) 96 // and calculate the cards that need to be scanned later (via scan_heap_roots()). 97 // If initial_evacuation is set, this is called during the initial evacuation. 98 void merge_heap_roots(bool initial_evacuation); 99 100 // Prepare for and cleanup after scanning the heap roots. Must be called 101 // once before and after in sequential code. 102 void prepare_for_scan_heap_roots(); 103 // Cleans the card table from temporary duplicate detection information. 104 void cleanup_after_scan_heap_roots(); 105 // Excludes the given region from heap root scanning. 106 void exclude_region_from_scan(uint region_idx); 107 // Creates a snapshot of the current _top values at the start of collection to 108 // filter out card marks that we do not want to scan. 109 void prepare_region_for_scan(HeapRegion* region); 110 111 // Do work for regions in the current increment of the collection set, scanning 112 // non-card based (heap) roots. 113 void scan_collection_set_regions(G1ParScanThreadState* pss, 114 uint worker_id, 115 G1GCPhaseTimes::GCParPhases scan_phase, 116 G1GCPhaseTimes::GCParPhases coderoots_phase, 117 G1GCPhaseTimes::GCParPhases objcopy_phase); 118 119 // Refine the card corresponding to "card_ptr". Safe to be called concurrently 120 // to the mutator. 121 void refine_card_concurrently(CardValue* card_ptr, 122 uint worker_id); 123 124 // Print accumulated summary info from the start of the VM. 125 void print_summary_info(); 126 127 // Print accumulated summary info from the last time called. 128 void print_periodic_summary_info(const char* header, uint period_count); 129 130 // Rebuilds the remembered set by scanning from bottom to TARS for all regions 131 // using the given work gang. 132 void rebuild_rem_set(G1ConcurrentMark* cm, WorkGang* workers, uint worker_id_offset); 133 }; 134 135 #endif // SHARE_GC_G1_G1REMSET_HPP