Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1OopClosures.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 818efdefcc99
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 class HeapRegion;
26 class G1CollectedHeap;
27 class G1RemSet;
28 class HRInto_G1RemSet;
29 class G1RemSet;
30 class ConcurrentMark;
31 class DirtyCardToOopClosure;
32 class CMBitMap;
33 class CMMarkStack;
34 class G1ParScanThreadState;
35
36 // A class that scans oops in a given heap region (much as OopsInGenClosure
37 // scans oops in a generation.)
38 class OopsInHeapRegionClosure: public OopsInGenClosure {
39 protected:
40 HeapRegion* _from;
41 public:
42 virtual void set_region(HeapRegion* from) { _from = from; }
43 };
44
45
46 class G1ScanAndBalanceClosure : public OopClosure {
47 G1CollectedHeap* _g1;
48 static int _nq;
49 public:
50 G1ScanAndBalanceClosure(G1CollectedHeap* g1) : _g1(g1) { }
51 inline void do_oop_nv(oop* p);
52 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
53 virtual void do_oop(oop* p);
54 virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
55 };
56
57 class G1ParClosureSuper : public OopsInHeapRegionClosure {
58 protected:
59 G1CollectedHeap* _g1;
60 G1RemSet* _g1_rem;
61 ConcurrentMark* _cm;
62 G1ParScanThreadState* _par_scan_state;
63 public:
64 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
65 bool apply_to_weak_ref_discovered_field() { return true; }
66 };
67
68 class G1ParScanClosure : public G1ParClosureSuper {
69 public:
70 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
71 G1ParClosureSuper(g1, par_scan_state) { }
72 void do_oop_nv(oop* p); // should be made inline
73 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
74 virtual void do_oop(oop* p) { do_oop_nv(p); }
75 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
76 };
77
78 #define G1_PARTIAL_ARRAY_MASK 1
79
80 class G1ParScanPartialArrayClosure : public G1ParClosureSuper {
81 G1ParScanClosure _scanner;
82 template <class T> void process_array_chunk(oop obj, int start, int end);
83 public:
84 G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
85 G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { }
86 void do_oop_nv(oop* p);
87 void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
88 virtual void do_oop(oop* p) { do_oop_nv(p); }
89 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
90 };
91
92
93 class G1ParCopyHelper : public G1ParClosureSuper {
94 G1ParScanClosure *_scanner;
95 protected:
96 void mark_forwardee(oop* p);
97 oop copy_to_survivor_space(oop obj);
98 public:
99 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state,
100 G1ParScanClosure *scanner) :
101 G1ParClosureSuper(g1, par_scan_state), _scanner(scanner) { }
102 };
103
104 template<bool do_gen_barrier, G1Barrier barrier, bool do_mark_forwardee>
105 class G1ParCopyClosure : public G1ParCopyHelper {
106 G1ParScanClosure _scanner;
107 void do_oop_work(oop* p);
108 void do_oop_work(narrowOop* p) { guarantee(false, "NYI"); }
109 public:
110 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
111 _scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { }
112 inline void do_oop_nv(oop* p) {
113 do_oop_work(p);
114 if (do_mark_forwardee)
115 mark_forwardee(p);
116 }
117 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
118 virtual void do_oop(oop* p) { do_oop_nv(p); }
119 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
120 };
121
122 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure;
123 typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure;
124 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure;
125 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure;
126 typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure;
127 typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure;
128 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure;
129
130
131 class FilterIntoCSClosure: public OopClosure {
132 G1CollectedHeap* _g1;
133 OopClosure* _oc;
134 DirtyCardToOopClosure* _dcto_cl;
135 public:
136 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl,
137 G1CollectedHeap* g1, OopClosure* oc) :
138 _dcto_cl(dcto_cl), _g1(g1), _oc(oc)
139 {}
140 inline void do_oop_nv(oop* p);
141 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
142 virtual void do_oop(oop* p);
143 virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
144 bool apply_to_weak_ref_discovered_field() { return true; }
145 bool do_header() { return false; }
146 };
147
148 class FilterInHeapRegionAndIntoCSClosure : public OopsInHeapRegionClosure {
149 G1CollectedHeap* _g1;
150 OopsInHeapRegionClosure* _oc;
151 public:
152 FilterInHeapRegionAndIntoCSClosure(G1CollectedHeap* g1,
153 OopsInHeapRegionClosure* oc) :
154 _g1(g1), _oc(oc)
155 {}
156 inline void do_oop_nv(oop* p);
157 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
158 virtual void do_oop(oop* p);
159 virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
160 bool apply_to_weak_ref_discovered_field() { return true; }
161 bool do_header() { return false; }
162 void set_region(HeapRegion* from) {
163 _oc->set_region(from);
164 }
165 };
166
167 class FilterAndMarkInHeapRegionAndIntoCSClosure : public OopsInHeapRegionClosure {
168 G1CollectedHeap* _g1;
169 ConcurrentMark* _cm;
170 OopsInHeapRegionClosure* _oc;
171 public:
172 FilterAndMarkInHeapRegionAndIntoCSClosure(G1CollectedHeap* g1,
173 OopsInHeapRegionClosure* oc,
174 ConcurrentMark* cm)
175 : _g1(g1), _oc(oc), _cm(cm) { }
176
177 inline void do_oop_nv(oop* p);
178 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
179 virtual void do_oop(oop* p);
180 virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
181 bool apply_to_weak_ref_discovered_field() { return true; }
182 bool do_header() { return false; }
183 void set_region(HeapRegion* from) {
184 _oc->set_region(from);
185 }
186 };
187
188 class FilterOutOfRegionClosure: public OopClosure {
189 HeapWord* _r_bottom;
190 HeapWord* _r_end;
191 OopClosure* _oc;
192 int _out_of_region;
193 public:
194 FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc);
195 inline void do_oop_nv(oop* p);
196 inline void do_oop_nv(narrowOop* p) { guarantee(false, "NYI"); }
197 virtual void do_oop(oop* p);
198 virtual void do_oop(narrowOop* p) { guarantee(false, "NYI"); }
199 bool apply_to_weak_ref_discovered_field() { return true; }
200 bool do_header() { return false; }
201 int out_of_region() { return _out_of_region; }
202 };