author | xdono |
Tue, 22 Sep 2009 14:06:10 -0700 | |
changeset 3795 | 6227ff014cfe |
parent 3696 | 9e5d9b5e1049 |
child 3919 | b15d85d98b61 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
3795 | 2 |
* Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. |
1 | 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 ReferenceProcessor; |
|
3696 | 26 |
class DataLayout; |
1 | 27 |
|
28 |
// MarkSweep takes care of global mark-compact garbage collection for a |
|
29 |
// GenCollectedHeap using a four-phase pointer forwarding algorithm. All |
|
30 |
// generations are assumed to support marking; those that can also support |
|
31 |
// compaction. |
|
32 |
// |
|
33 |
// Class unloading will only occur when a full gc is invoked. |
|
34 |
||
35 |
// If VALIDATE_MARK_SWEEP is defined, the -XX:+ValidateMarkSweep flag will |
|
36 |
// be operational, and will provide slow but comprehensive self-checks within |
|
37 |
// the GC. This is not enabled by default in product or release builds, |
|
38 |
// since the extra call to track_adjusted_pointer() in _adjust_pointer() |
|
39 |
// would be too much overhead, and would disturb performance measurement. |
|
40 |
// However, debug builds are sometimes way too slow to run GC tests! |
|
41 |
#ifdef ASSERT |
|
42 |
#define VALIDATE_MARK_SWEEP 1 |
|
43 |
#endif |
|
44 |
#ifdef VALIDATE_MARK_SWEEP |
|
45 |
#define VALIDATE_MARK_SWEEP_ONLY(code) code |
|
46 |
#else |
|
47 |
#define VALIDATE_MARK_SWEEP_ONLY(code) |
|
48 |
#endif |
|
49 |
||
50 |
// declared at end |
|
51 |
class PreservedMark; |
|
52 |
||
53 |
class MarkSweep : AllStatic { |
|
54 |
// |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
55 |
// Inline closure decls |
1 | 56 |
// |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
57 |
class FollowRootClosure: public OopsInGenClosure { |
1 | 58 |
public: |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
59 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
60 |
virtual void do_oop(narrowOop* p); |
1 | 61 |
virtual const bool do_nmethods() const { return true; } |
62 |
}; |
|
63 |
||
64 |
class MarkAndPushClosure: public OopClosure { |
|
65 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
66 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
67 |
virtual void do_oop(narrowOop* p); |
1 | 68 |
virtual const bool do_nmethods() const { return true; } |
3696 | 69 |
virtual const bool should_remember_mdo() const { return true; } |
70 |
virtual void remember_mdo(DataLayout* p) { MarkSweep::revisit_mdo(p); } |
|
1 | 71 |
}; |
72 |
||
73 |
class FollowStackClosure: public VoidClosure { |
|
74 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
75 |
virtual void do_void(); |
1 | 76 |
}; |
77 |
||
78 |
class AdjustPointerClosure: public OopsInGenClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
79 |
private: |
1 | 80 |
bool _is_root; |
81 |
public: |
|
82 |
AdjustPointerClosure(bool is_root) : _is_root(is_root) {} |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
83 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
84 |
virtual void do_oop(narrowOop* p); |
1 | 85 |
}; |
86 |
||
87 |
// Used for java/lang/ref handling |
|
88 |
class IsAliveClosure: public BoolObjectClosure { |
|
89 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
90 |
virtual void do_object(oop p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
91 |
virtual bool do_object_b(oop p); |
1 | 92 |
}; |
93 |
||
94 |
class KeepAliveClosure: public OopClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
95 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
96 |
template <class T> void do_oop_work(T* p); |
1 | 97 |
public: |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
98 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
99 |
virtual void do_oop(narrowOop* p); |
1 | 100 |
}; |
101 |
||
102 |
// |
|
103 |
// Friend decls |
|
104 |
// |
|
105 |
friend class AdjustPointerClosure; |
|
106 |
friend class KeepAliveClosure; |
|
107 |
friend class VM_MarkSweep; |
|
108 |
friend void marksweep_init(); |
|
3696 | 109 |
friend class DataLayout; |
1 | 110 |
|
111 |
// |
|
112 |
// Vars |
|
113 |
// |
|
114 |
protected: |
|
115 |
// Traversal stack used during phase1 |
|
116 |
static GrowableArray<oop>* _marking_stack; |
|
117 |
// Stack for live klasses to revisit at end of marking phase |
|
118 |
static GrowableArray<Klass*>* _revisit_klass_stack; |
|
3696 | 119 |
// Set (stack) of MDO's to revisit at end of marking phase |
120 |
static GrowableArray<DataLayout*>* _revisit_mdo_stack; |
|
1 | 121 |
|
122 |
// Space for storing/restoring mark word |
|
123 |
static GrowableArray<markOop>* _preserved_mark_stack; |
|
124 |
static GrowableArray<oop>* _preserved_oop_stack; |
|
125 |
static size_t _preserved_count; |
|
126 |
static size_t _preserved_count_max; |
|
127 |
static PreservedMark* _preserved_marks; |
|
128 |
||
129 |
// Reference processing (used in ...follow_contents) |
|
130 |
static ReferenceProcessor* _ref_processor; |
|
131 |
||
132 |
#ifdef VALIDATE_MARK_SWEEP |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
133 |
static GrowableArray<void*>* _root_refs_stack; |
1 | 134 |
static GrowableArray<oop> * _live_oops; |
135 |
static GrowableArray<oop> * _live_oops_moved_to; |
|
136 |
static GrowableArray<size_t>* _live_oops_size; |
|
137 |
static size_t _live_oops_index; |
|
138 |
static size_t _live_oops_index_at_perm; |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
139 |
static GrowableArray<void*>* _other_refs_stack; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
140 |
static GrowableArray<void*>* _adjusted_pointers; |
1 | 141 |
static bool _pointer_tracking; |
142 |
static bool _root_tracking; |
|
143 |
||
144 |
// The following arrays are saved since the time of the last GC and |
|
145 |
// assist in tracking down problems where someone has done an errant |
|
146 |
// store into the heap, usually to an oop that wasn't properly |
|
147 |
// handleized across a GC. If we crash or otherwise fail before the |
|
148 |
// next GC, we can query these arrays to find out the object we had |
|
149 |
// intended to do the store to (assuming it is still alive) and the |
|
150 |
// offset within that object. Covered under RecordMarkSweepCompaction. |
|
151 |
static GrowableArray<HeapWord*> * _cur_gc_live_oops; |
|
152 |
static GrowableArray<HeapWord*> * _cur_gc_live_oops_moved_to; |
|
153 |
static GrowableArray<size_t>* _cur_gc_live_oops_size; |
|
154 |
static GrowableArray<HeapWord*> * _last_gc_live_oops; |
|
155 |
static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to; |
|
156 |
static GrowableArray<size_t>* _last_gc_live_oops_size; |
|
157 |
#endif |
|
158 |
||
159 |
// Non public closures |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
160 |
static IsAliveClosure is_alive; |
1 | 161 |
static KeepAliveClosure keep_alive; |
162 |
||
163 |
// Class unloading. Update subklass/sibling/implementor links at end of marking phase. |
|
164 |
static void follow_weak_klass_links(); |
|
165 |
||
3696 | 166 |
// Class unloading. Clear weak refs in MDO's (ProfileData) |
167 |
// at the end of the marking phase. |
|
168 |
static void follow_mdo_weak_refs(); |
|
169 |
||
1 | 170 |
// Debugging |
171 |
static void trace(const char* msg) PRODUCT_RETURN; |
|
172 |
||
173 |
public: |
|
174 |
// Public closures |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
175 |
static FollowRootClosure follow_root_closure; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
176 |
static MarkAndPushClosure mark_and_push_closure; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
177 |
static FollowStackClosure follow_stack_closure; |
1 | 178 |
static AdjustPointerClosure adjust_root_pointer_closure; |
179 |
static AdjustPointerClosure adjust_pointer_closure; |
|
180 |
||
181 |
// Reference Processing |
|
182 |
static ReferenceProcessor* const ref_processor() { return _ref_processor; } |
|
183 |
||
184 |
// Call backs for marking |
|
185 |
static void mark_object(oop obj); |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
186 |
// Mark pointer and follow contents. Empty marking stack afterwards. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
187 |
template <class T> static inline void follow_root(T* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
188 |
// Mark pointer and follow contents. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
189 |
template <class T> static inline void mark_and_follow(T* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
190 |
// Check mark and maybe push on marking stack |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
191 |
template <class T> static inline void mark_and_push(T* p); |
1 | 192 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
193 |
static void follow_stack(); // Empty marking stack. |
1 | 194 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
195 |
static void preserve_mark(oop p, markOop mark); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
196 |
// Save the mark word so it can be restored later |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
197 |
static void adjust_marks(); // Adjust the pointers in the preserved marks table |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
198 |
static void restore_marks(); // Restore the marks that we saved in preserve_mark |
1 | 199 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
200 |
template <class T> static inline void adjust_pointer(T* p, bool isroot); |
1 | 201 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
202 |
static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
203 |
static void adjust_pointer(oop* p) { adjust_pointer(p, false); } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
204 |
static void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); } |
1 | 205 |
|
206 |
#ifdef VALIDATE_MARK_SWEEP |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
207 |
static void track_adjusted_pointer(void* p, bool isroot); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
208 |
static void check_adjust_pointer(void* p); |
1 | 209 |
static void track_interior_pointers(oop obj); |
210 |
static void check_interior_pointers(); |
|
211 |
||
212 |
static void reset_live_oop_tracking(bool at_perm); |
|
213 |
static void register_live_oop(oop p, size_t size); |
|
214 |
static void validate_live_oop(oop p, size_t size); |
|
215 |
static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top); |
|
216 |
static void compaction_complete(); |
|
217 |
||
218 |
// Querying operation of RecordMarkSweepCompaction results. |
|
219 |
// Finds and prints the current base oop and offset for a word |
|
220 |
// within an oop that was live during the last GC. Helpful for |
|
221 |
// tracking down heap stomps. |
|
222 |
static void print_new_location_of_heap_address(HeapWord* q); |
|
223 |
#endif |
|
224 |
||
225 |
// Call backs for class unloading |
|
3696 | 226 |
// Update subklass/sibling/implementor links at end of marking. |
227 |
static void revisit_weak_klass_link(Klass* k); |
|
228 |
// For weak refs clearing in MDO's |
|
229 |
static void revisit_mdo(DataLayout* p); |
|
1 | 230 |
}; |
231 |
||
232 |
class PreservedMark VALUE_OBJ_CLASS_SPEC { |
|
233 |
private: |
|
234 |
oop _obj; |
|
235 |
markOop _mark; |
|
236 |
||
237 |
public: |
|
238 |
void init(oop obj, markOop mark) { |
|
239 |
_obj = obj; |
|
240 |
_mark = mark; |
|
241 |
} |
|
242 |
||
243 |
void adjust_pointer() { |
|
244 |
MarkSweep::adjust_pointer(&_obj); |
|
245 |
} |
|
246 |
||
247 |
void restore() { |
|
248 |
_obj->set_mark(_mark); |
|
249 |
} |
|
250 |
}; |