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_VM_GC_G1_G1REMSET_HPP
26 #define SHARE_VM_GC_G1_G1REMSET_HPP
27
28 #include "gc/g1/dirtyCardQueue.hpp"
29 #include "gc/g1/g1CardTable.hpp"
30 #include "gc/g1/g1OopClosures.hpp"
31 #include "gc/g1/g1RemSetSummary.hpp"
32 #include "gc/g1/heapRegion.hpp"
33 #include "memory/allocation.hpp"
34 #include "memory/iterator.hpp"
35
36 // A G1RemSet provides ways of iterating over pointers into a selected
37 // collection set.
38
39 class BitMap;
40 class CardTableBarrierSet;
41 class G1BlockOffsetTable;
42 class CodeBlobClosure;
43 class G1CollectedHeap;
44 class G1CMBitMap;
45 class G1HotCardCache;
46 class G1RemSetScanState;
47 class G1ParScanThreadState;
48 class G1Policy;
49 class G1ScanObjsDuringScanRSClosure;
50 class G1ScanObjsDuringUpdateRSClosure;
51 class HeapRegionClaimer;
52
53 // A G1RemSet in which each heap region has a rem set that records the
54 // external heap references into it. Uses a mod ref bs to track updates,
55 // so that they can be used to update the individual region remsets.
56 class G1RemSet: public CHeapObj<mtGC> {
57 private:
58 G1RemSetScanState* _scan_state;
59
60 G1RemSetSummary _prev_period_summary;
61
62 // Scan all remembered sets of the collection set for references into the collection
63 // set.
64 void scan_rem_set(G1ParScanThreadState* pss,
65 CodeBlobClosure* heap_region_codeblobs,
66 uint worker_i);
67
68 // Flush remaining refinement buffers for cross-region references to either evacuate references
69 // into the collection set or update the remembered set.
70 void update_rem_set(G1ParScanThreadState* pss, uint worker_i);
71
72 G1CollectedHeap* _g1h;
73 size_t _num_conc_refined_cards; // Number of cards refined concurrently to the mutator.
74
75 G1CardTable* _ct;
76 G1Policy* _g1p;
77 G1HotCardCache* _hot_card_cache;
78
79 public:
80 // Gives an approximation on how many threads can be expected to add records to
81 // a remembered set in parallel. This can be used for sizing data structures to
82 // decrease performance losses due to data structure sharing.
83 // Examples for quantities that influence this value are the maximum number of
84 // mutator threads, maximum number of concurrent refinement or GC threads.
85 static uint num_par_rem_sets();
86
87 // Initialize data that depends on the heap size being known.
88 void initialize(size_t capacity, uint max_regions);
89
90 // This is called to reset dual hash tables after the gc pause
91 // is finished and the initial hash table is no longer being
92 // scanned.
93 void cleanupHRRS();
94
95 G1RemSet(G1CollectedHeap* g1h,
96 G1CardTable* ct,
97 G1HotCardCache* hot_card_cache);
98 ~G1RemSet();
99
100 // Process all oops in the collection set from the cards in the refinement buffers and
101 // remembered sets using pss.
102 //
103 // Further applies heap_region_codeblobs on the oops of the unmarked nmethods on the strong code
104 // roots list for each region in the collection set.
105 void oops_into_collection_set_do(G1ParScanThreadState* pss,
106 CodeBlobClosure* heap_region_codeblobs,
107 uint worker_i);
108
109 // Prepare for and cleanup after an oops_into_collection_set_do
110 // call. Must call each of these once before and after (in sequential
111 // code) any thread calls oops_into_collection_set_do.
112 void prepare_for_oops_into_collection_set_do();
113 void cleanup_after_oops_into_collection_set_do();
114
115 G1RemSetScanState* scan_state() const { return _scan_state; }
116
117 // Refine the card corresponding to "card_ptr". Safe to be called concurrently
118 // to the mutator.
119 void refine_card_concurrently(jbyte* card_ptr,
120 uint worker_i);
121
122 // Refine the card corresponding to "card_ptr", applying the given closure to
123 // all references found. Must only be called during gc.
124 // Returns whether the card has been scanned.
125 bool refine_card_during_gc(jbyte* card_ptr, G1ScanObjsDuringUpdateRSClosure* update_rs_cl);
126
127 // Print accumulated summary info from the start of the VM.
128 void print_summary_info();
129
130 // Print accumulated summary info from the last time called.
131 void print_periodic_summary_info(const char* header, uint period_count);
132
133 size_t num_conc_refined_cards() const { return _num_conc_refined_cards; }
134
135 // Rebuilds the remembered set by scanning from bottom to TARS for all regions
136 // using the given work gang.
137 void rebuild_rem_set(G1ConcurrentMark* cm, WorkGang* workers, uint worker_id_offset);
138 };
139
140 class G1ScanRSForRegionClosure : public HeapRegionClosure {
141 G1RemSetScanState* _scan_state;
142
143 size_t _cards_scanned;
144 size_t _cards_claimed;
145 size_t _cards_skipped;
146
147 G1CollectedHeap* _g1h;
148
149 G1ScanObjsDuringScanRSClosure* _scan_objs_on_card_cl;
150 CodeBlobClosure* _code_root_cl;
151
152 G1BlockOffsetTable* _bot;
153 G1CardTable *_ct;
154
155 double _strong_code_root_scan_time_sec;
156 uint _worker_i;
157
158 void claim_card(size_t card_index, const uint region_idx_for_card);
159 void scan_card(MemRegion mr, uint region_idx_for_card);
160 void scan_strong_code_roots(HeapRegion* r);
161 public:
162 G1ScanRSForRegionClosure(G1RemSetScanState* scan_state,
163 G1ScanObjsDuringScanRSClosure* scan_obj_on_card,
164 CodeBlobClosure* code_root_cl,
165 uint worker_i);
166
167 bool do_heap_region(HeapRegion* r);
168
169 double strong_code_root_scan_time_sec() {
170 return _strong_code_root_scan_time_sec;
171 }
172
173 size_t cards_scanned() const { return _cards_scanned; }
174 size_t cards_claimed() const { return _cards_claimed; }
175 size_t cards_skipped() const { return _cards_skipped; }
176 };
177
178 #endif // SHARE_VM_GC_G1_G1REMSET_HPP
|
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_VM_GC_G1_G1REMSET_HPP
26 #define SHARE_VM_GC_G1_G1REMSET_HPP
27
28 #include "gc/g1/dirtyCardQueue.hpp"
29 #include "gc/g1/g1CardTable.hpp"
30 #include "gc/g1/g1OopClosures.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 G1Policy;
50 class G1ScanObjsDuringScanRSClosure;
51 class G1ScanObjsDuringUpdateRSClosure;
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 // Scan all remembered sets of the collection set for references into the collection
64 // set.
65 void scan_rem_set(G1ParScanThreadState* pss, uint worker_i);
66
67 // Flush remaining refinement buffers for cross-region references to either evacuate references
68 // into the collection set or update the remembered set.
69 void update_rem_set(G1ParScanThreadState* pss, uint worker_i);
70
71 G1CollectedHeap* _g1h;
72 size_t _num_conc_refined_cards; // Number of cards refined concurrently to the mutator.
73
74 G1CardTable* _ct;
75 G1Policy* _g1p;
76 G1HotCardCache* _hot_card_cache;
77
78 public:
79 // Gives an approximation on how many threads can be expected to add records to
80 // a remembered set in parallel. This can be used for sizing data structures to
81 // decrease performance losses due to data structure sharing.
82 // Examples for quantities that influence this value are the maximum number of
83 // mutator threads, maximum number of concurrent refinement or GC threads.
84 static uint num_par_rem_sets();
85
86 // Initialize data that depends on the heap size being known.
87 void initialize(size_t capacity, uint max_regions);
88
89 // This is called to reset dual hash tables after the gc pause
90 // is finished and the initial hash table is no longer being
91 // scanned.
92 void cleanupHRRS();
93
94 G1RemSet(G1CollectedHeap* g1h,
95 G1CardTable* ct,
96 G1HotCardCache* hot_card_cache);
97 ~G1RemSet();
98
99 // Process all oops in the collection set from the cards in the refinement buffers and
100 // remembered sets using pss.
101 //
102 // Further applies heap_region_codeblobs on the oops of the unmarked nmethods on the strong code
103 // roots list for each region in the collection set.
104 void oops_into_collection_set_do(G1ParScanThreadState* pss, uint worker_i);
105
106 // Prepare for and cleanup after an oops_into_collection_set_do
107 // call. Must call each of these once before and after (in sequential
108 // code) any thread calls oops_into_collection_set_do.
109 void prepare_for_oops_into_collection_set_do();
110 void cleanup_after_oops_into_collection_set_do();
111
112 G1RemSetScanState* scan_state() const { return _scan_state; }
113
114 // Refine the card corresponding to "card_ptr". Safe to be called concurrently
115 // to the mutator.
116 void refine_card_concurrently(jbyte* card_ptr,
117 uint worker_i);
118
119 // Refine the card corresponding to "card_ptr", applying the given closure to
120 // all references found. Must only be called during gc.
121 // Returns whether the card has been scanned.
122 bool refine_card_during_gc(jbyte* card_ptr, G1ScanObjsDuringUpdateRSClosure* update_rs_cl);
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 size_t num_conc_refined_cards() const { return _num_conc_refined_cards; }
131
132 // Rebuilds the remembered set by scanning from bottom to TARS for all regions
133 // using the given work gang.
134 void rebuild_rem_set(G1ConcurrentMark* cm, WorkGang* workers, uint worker_id_offset);
135 };
136
137 class G1ScanRSForRegionClosure : public HeapRegionClosure {
138 G1CollectedHeap* _g1h;
139 G1CardTable *_ct;
140
141 G1ParScanThreadState* _pss;
142 G1ScanObjsDuringScanRSClosure* _scan_objs_on_card_cl;
143
144 G1RemSetScanState* _scan_state;
145
146 uint _worker_i;
147
148 size_t _cards_scanned;
149 size_t _cards_claimed;
150 size_t _cards_skipped;
151
152 Tickspan _rem_set_root_scan_time;
153 Tickspan _rem_set_trim_partially_time;
154
155 Tickspan _strong_code_root_scan_time;
156 Tickspan _strong_code_trim_partially_time;
157
158 void claim_card(size_t card_index, const uint region_idx_for_card);
159 void scan_card(MemRegion mr, uint region_idx_for_card);
160
161 void scan_rem_set_roots(HeapRegion* r);
162 void scan_strong_code_roots(HeapRegion* r);
163 public:
164 G1ScanRSForRegionClosure(G1RemSetScanState* scan_state,
165 G1ScanObjsDuringScanRSClosure* scan_obj_on_card,
166 G1ParScanThreadState* pss,
167 uint worker_i);
168
169 bool do_heap_region(HeapRegion* r);
170
171 Tickspan rem_set_root_scan_time() const { return _rem_set_root_scan_time; }
172 Tickspan rem_set_trim_partially_time() const { return _rem_set_trim_partially_time; }
173
174 Tickspan strong_code_root_scan_time() { return _strong_code_root_scan_time; }
175 Tickspan strong_code_root_trim_partially_time() { return _strong_code_trim_partially_time; }
176
177 size_t cards_scanned() const { return _cards_scanned; }
178 size_t cards_claimed() const { return _cards_claimed; }
179 size_t cards_skipped() const { return _cards_skipped; }
180 };
181
182 #endif // SHARE_VM_GC_G1_G1REMSET_HPP
|