Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1RemSet.hpp @ 342:37f87013dfd8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6711316: Open source the Garbage-First garbage collector Summary: First mercurial integration of the code for the Garbage-First garbage collector. Reviewed-by: apetrusenko, iveresov, jmasa, sgoldman, tonyp, ysr
author ysr
date Thu, 05 Jun 2008 15:57:56 -0700
parents
children fe3d7c11b4b7
comparison
equal deleted inserted replaced
189:0b27f3512f9e 342:37f87013dfd8
1 /*
2 * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 // A G1RemSet provides ways of iterating over pointers into a selected
26 // collection set.
27
28 class G1CollectedHeap;
29 class CardTableModRefBarrierSet;
30 class HRInto_G1RemSet;
31 class ConcurrentG1Refine;
32
33 class G1RemSet {
34 protected:
35 G1CollectedHeap* _g1;
36
37 unsigned _conc_refine_traversals;
38 unsigned _conc_refine_cards;
39
40 size_t n_workers();
41
42 public:
43 G1RemSet(G1CollectedHeap* g1) :
44 _g1(g1), _conc_refine_traversals(0), _conc_refine_cards(0)
45 {}
46
47 // Invoke "blk->do_oop" on all pointers into the CS in object in regions
48 // outside the CS (having invoked "blk->set_region" to set the "from"
49 // region correctly beforehand.) The "worker_i" param is for the
50 // parallel case where the number of the worker thread calling this
51 // function can be helpful in partitioning the work to be done. It
52 // should be the same as the "i" passed to the calling thread's
53 // work(i) function. In the sequential case this param will be ingored.
54 virtual void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
55 int worker_i) = 0;
56
57 // Prepare for and cleanup after an oops_into_collection_set_do
58 // call. Must call each of these once before and after (in sequential
59 // code) any threads call oops into collection set do. (This offers an
60 // opportunity to sequential setup and teardown of structures needed by a
61 // parallel iteration over the CS's RS.)
62 virtual void prepare_for_oops_into_collection_set_do() = 0;
63 virtual void cleanup_after_oops_into_collection_set_do() = 0;
64
65 // If "this" is of the given subtype, return "this", else "NULL".
66 virtual HRInto_G1RemSet* as_HRInto_G1RemSet() { return NULL; }
67
68 // Record, if necessary, the fact that *p (where "p" is in region "from")
69 // has changed to its new value.
70 virtual void write_ref(HeapRegion* from, oop* p) = 0;
71 virtual void par_write_ref(HeapRegion* from, oop* p, int tid) = 0;
72
73 // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
74 // or card, respectively, such that a region or card with a corresponding
75 // 0 bit contains no part of any live object. Eliminates any remembered
76 // set entries that correspond to dead heap ranges.
77 virtual void scrub(BitMap* region_bm, BitMap* card_bm) = 0;
78 // Like the above, but assumes is called in parallel: "worker_num" is the
79 // parallel thread id of the current thread, and "claim_val" is the
80 // value that should be used to claim heap regions.
81 virtual void scrub_par(BitMap* region_bm, BitMap* card_bm,
82 int worker_num, int claim_val) = 0;
83
84 // Do any "refinement" activity that might be appropriate to the given
85 // G1RemSet. If "refinement" has iterateive "passes", do one pass.
86 // If "t" is non-NULL, it is the thread performing the refinement.
87 // Default implementation does nothing.
88 virtual void concurrentRefinementPass(ConcurrentG1Refine* cg1r) {}
89
90 // Refine the card corresponding to "card_ptr". If "sts" is non-NULL,
91 // join and leave around parts that must be atomic wrt GC. (NULL means
92 // being done at a safepoint.)
93 virtual void concurrentRefineOneCard(jbyte* card_ptr, int worker_i) {}
94
95 unsigned conc_refine_cards() { return _conc_refine_cards; }
96
97 // Print any relevant summary info.
98 virtual void print_summary_info() {}
99
100 // Prepare remebered set for verification.
101 virtual void prepare_for_verify() {};
102 };
103
104
105 // The simplest possible G1RemSet: iterates over all objects in non-CS
106 // regions, searching for pointers into the CS.
107 class StupidG1RemSet: public G1RemSet {
108 public:
109 StupidG1RemSet(G1CollectedHeap* g1) : G1RemSet(g1) {}
110
111 void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
112 int worker_i);
113
114 void prepare_for_oops_into_collection_set_do() {}
115 void cleanup_after_oops_into_collection_set_do() {}
116
117 // Nothing is necessary in the version below.
118 void write_ref(HeapRegion* from, oop* p) {}
119 void par_write_ref(HeapRegion* from, oop* p, int tid) {}
120
121 void scrub(BitMap* region_bm, BitMap* card_bm) {}
122 void scrub_par(BitMap* region_bm, BitMap* card_bm,
123 int worker_num, int claim_val) {}
124
125 };
126
127 // A G1RemSet in which each heap region has a rem set that records the
128 // external heap references into it. Uses a mod ref bs to track updates,
129 // so that they can be used to update the individual region remsets.
130
131 class HRInto_G1RemSet: public G1RemSet {
132 protected:
133 enum SomePrivateConstants {
134 UpdateRStoMergeSync = 0,
135 MergeRStoDoDirtySync = 1,
136 DoDirtySync = 2,
137 LastSync = 3,
138
139 SeqTask = 0,
140 NumSeqTasks = 1
141 };
142
143 CardTableModRefBS* _ct_bs;
144 SubTasksDone* _seq_task;
145 G1CollectorPolicy* _g1p;
146
147 ConcurrentG1Refine* _cg1r;
148
149 size_t* _cards_scanned;
150 size_t _total_cards_scanned;
151
152 // _par_traversal_in_progress is "true" iff a parallel traversal is in
153 // progress. If so, then cards added to remembered sets should also have
154 // their references into the collection summarized in "_new_refs".
155 bool _par_traversal_in_progress;
156 void set_par_traversal(bool b);
157 GrowableArray<oop*>** _new_refs;
158
159 public:
160 // This is called to reset dual hash tables after the gc pause
161 // is finished and the initial hash table is no longer being
162 // scanned.
163 void cleanupHRRS();
164
165 HRInto_G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs);
166 ~HRInto_G1RemSet();
167
168 void oops_into_collection_set_do(OopsInHeapRegionClosure* blk,
169 int worker_i);
170
171 void prepare_for_oops_into_collection_set_do();
172 void cleanup_after_oops_into_collection_set_do();
173 void scanRS(OopsInHeapRegionClosure* oc, int worker_i);
174 void scanNewRefsRS(OopsInHeapRegionClosure* oc, int worker_i);
175 void updateRS(int worker_i);
176 HeapRegion* calculateStartRegion(int i);
177
178 HRInto_G1RemSet* as_HRInto_G1RemSet() { return this; }
179
180 CardTableModRefBS* ct_bs() { return _ct_bs; }
181 size_t cardsScanned() { return _total_cards_scanned; }
182
183 // Record, if necessary, the fact that *p (where "p" is in region "from",
184 // which is required to be non-NULL) has changed to a new non-NULL value.
185 inline void write_ref(HeapRegion* from, oop* p);
186 // The "_nv" version is the same; it exists just so that it is not virtual.
187 inline void write_ref_nv(HeapRegion* from, oop* p);
188
189 inline bool self_forwarded(oop obj);
190 inline void par_write_ref(HeapRegion* from, oop* p, int tid);
191
192 void scrub(BitMap* region_bm, BitMap* card_bm);
193 void scrub_par(BitMap* region_bm, BitMap* card_bm,
194 int worker_num, int claim_val);
195
196 virtual void concurrentRefinementPass(ConcurrentG1Refine* t);
197 virtual void concurrentRefineOneCard(jbyte* card_ptr, int worker_i);
198
199 virtual void print_summary_info();
200 virtual void prepare_for_verify();
201 };
202
203 #define G1_REM_SET_LOGGING 0
204
205 class CountNonCleanMemRegionClosure: public MemRegionClosure {
206 G1CollectedHeap* _g1;
207 int _n;
208 HeapWord* _start_first;
209 public:
210 CountNonCleanMemRegionClosure(G1CollectedHeap* g1) :
211 _g1(g1), _n(0), _start_first(NULL)
212 {}
213 void do_MemRegion(MemRegion mr);
214 int n() { return _n; };
215 HeapWord* start_first() { return _start_first; }
216 };