|
342
|
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 };
|
