author | zgu |
Thu, 28 Jun 2012 17:03:16 -0400 | |
changeset 13195 | be27e1b6a4b9 |
parent 11178 | 8318f84ac604 |
child 13728 | 882756847a04 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
11178
8318f84ac604
7112997: Remove obsolete code ResetObjectsClosure and VerifyUpdateClosure
jmasa
parents:
7397
diff
changeset
|
2 |
* Copyright (c) 1997, 2011, Oracle and/or its affiliates. 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5076
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5076
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5076
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_MARKSWEEP_HPP |
26 |
#define SHARE_VM_GC_IMPLEMENTATION_SHARED_MARKSWEEP_HPP |
|
27 |
||
28 |
#include "gc_interface/collectedHeap.hpp" |
|
29 |
#include "memory/universe.hpp" |
|
30 |
#include "oops/markOop.hpp" |
|
31 |
#include "oops/oop.hpp" |
|
32 |
#include "runtime/timer.hpp" |
|
33 |
#include "utilities/growableArray.hpp" |
|
34 |
#include "utilities/stack.hpp" |
|
35 |
#include "utilities/taskqueue.hpp" |
|
36 |
||
1 | 37 |
class ReferenceProcessor; |
3696 | 38 |
class DataLayout; |
1 | 39 |
|
40 |
// MarkSweep takes care of global mark-compact garbage collection for a |
|
41 |
// GenCollectedHeap using a four-phase pointer forwarding algorithm. All |
|
42 |
// generations are assumed to support marking; those that can also support |
|
43 |
// compaction. |
|
44 |
// |
|
45 |
// Class unloading will only occur when a full gc is invoked. |
|
46 |
||
47 |
// If VALIDATE_MARK_SWEEP is defined, the -XX:+ValidateMarkSweep flag will |
|
48 |
// be operational, and will provide slow but comprehensive self-checks within |
|
49 |
// the GC. This is not enabled by default in product or release builds, |
|
50 |
// since the extra call to track_adjusted_pointer() in _adjust_pointer() |
|
51 |
// would be too much overhead, and would disturb performance measurement. |
|
52 |
// However, debug builds are sometimes way too slow to run GC tests! |
|
53 |
#ifdef ASSERT |
|
54 |
#define VALIDATE_MARK_SWEEP 1 |
|
55 |
#endif |
|
56 |
#ifdef VALIDATE_MARK_SWEEP |
|
57 |
#define VALIDATE_MARK_SWEEP_ONLY(code) code |
|
58 |
#else |
|
59 |
#define VALIDATE_MARK_SWEEP_ONLY(code) |
|
60 |
#endif |
|
61 |
||
62 |
// declared at end |
|
63 |
class PreservedMark; |
|
64 |
||
65 |
class MarkSweep : AllStatic { |
|
66 |
// |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
67 |
// Inline closure decls |
1 | 68 |
// |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
69 |
class FollowRootClosure: public OopsInGenClosure { |
1 | 70 |
public: |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
71 |
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
|
72 |
virtual void do_oop(narrowOop* p); |
1 | 73 |
}; |
74 |
||
75 |
class MarkAndPushClosure: public OopClosure { |
|
76 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
77 |
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
|
78 |
virtual void do_oop(narrowOop* p); |
3696 | 79 |
virtual const bool should_remember_mdo() const { return true; } |
80 |
virtual void remember_mdo(DataLayout* p) { MarkSweep::revisit_mdo(p); } |
|
1 | 81 |
}; |
82 |
||
83 |
class FollowStackClosure: public VoidClosure { |
|
84 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
85 |
virtual void do_void(); |
1 | 86 |
}; |
87 |
||
88 |
class AdjustPointerClosure: public OopsInGenClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
89 |
private: |
1 | 90 |
bool _is_root; |
91 |
public: |
|
92 |
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
|
93 |
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
|
94 |
virtual void do_oop(narrowOop* p); |
1 | 95 |
}; |
96 |
||
97 |
// Used for java/lang/ref handling |
|
98 |
class IsAliveClosure: public BoolObjectClosure { |
|
99 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
100 |
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
|
101 |
virtual bool do_object_b(oop p); |
1 | 102 |
}; |
103 |
||
104 |
class KeepAliveClosure: public OopClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
105 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
106 |
template <class T> void do_oop_work(T* p); |
1 | 107 |
public: |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
108 |
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
|
109 |
virtual void do_oop(narrowOop* p); |
1 | 110 |
}; |
111 |
||
112 |
// |
|
113 |
// Friend decls |
|
114 |
// |
|
115 |
friend class AdjustPointerClosure; |
|
116 |
friend class KeepAliveClosure; |
|
117 |
friend class VM_MarkSweep; |
|
118 |
friend void marksweep_init(); |
|
119 |
||
120 |
// |
|
121 |
// Vars |
|
122 |
// |
|
123 |
protected: |
|
5076
8b74a4b60b31
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
3919
diff
changeset
|
124 |
// Traversal stacks used during phase1 |
13195 | 125 |
static Stack<oop, mtGC> _marking_stack; |
126 |
static Stack<ObjArrayTask, mtGC> _objarray_stack; |
|
1 | 127 |
// Stack for live klasses to revisit at end of marking phase |
13195 | 128 |
static Stack<Klass*, mtGC> _revisit_klass_stack; |
3696 | 129 |
// Set (stack) of MDO's to revisit at end of marking phase |
13195 | 130 |
static Stack<DataLayout*, mtGC> _revisit_mdo_stack; |
1 | 131 |
|
132 |
// Space for storing/restoring mark word |
|
13195 | 133 |
static Stack<markOop, mtGC> _preserved_mark_stack; |
134 |
static Stack<oop, mtGC> _preserved_oop_stack; |
|
1 | 135 |
static size_t _preserved_count; |
136 |
static size_t _preserved_count_max; |
|
137 |
static PreservedMark* _preserved_marks; |
|
138 |
||
139 |
// Reference processing (used in ...follow_contents) |
|
140 |
static ReferenceProcessor* _ref_processor; |
|
141 |
||
142 |
#ifdef VALIDATE_MARK_SWEEP |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
143 |
static GrowableArray<void*>* _root_refs_stack; |
1 | 144 |
static GrowableArray<oop> * _live_oops; |
145 |
static GrowableArray<oop> * _live_oops_moved_to; |
|
146 |
static GrowableArray<size_t>* _live_oops_size; |
|
147 |
static size_t _live_oops_index; |
|
148 |
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
|
149 |
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
|
150 |
static GrowableArray<void*>* _adjusted_pointers; |
1 | 151 |
static bool _pointer_tracking; |
152 |
static bool _root_tracking; |
|
153 |
||
154 |
// The following arrays are saved since the time of the last GC and |
|
155 |
// assist in tracking down problems where someone has done an errant |
|
156 |
// store into the heap, usually to an oop that wasn't properly |
|
157 |
// handleized across a GC. If we crash or otherwise fail before the |
|
158 |
// next GC, we can query these arrays to find out the object we had |
|
159 |
// intended to do the store to (assuming it is still alive) and the |
|
160 |
// offset within that object. Covered under RecordMarkSweepCompaction. |
|
161 |
static GrowableArray<HeapWord*> * _cur_gc_live_oops; |
|
162 |
static GrowableArray<HeapWord*> * _cur_gc_live_oops_moved_to; |
|
163 |
static GrowableArray<size_t>* _cur_gc_live_oops_size; |
|
164 |
static GrowableArray<HeapWord*> * _last_gc_live_oops; |
|
165 |
static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to; |
|
166 |
static GrowableArray<size_t>* _last_gc_live_oops_size; |
|
167 |
#endif |
|
168 |
||
169 |
// Non public closures |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
170 |
static IsAliveClosure is_alive; |
1 | 171 |
static KeepAliveClosure keep_alive; |
172 |
||
173 |
// Class unloading. Update subklass/sibling/implementor links at end of marking phase. |
|
174 |
static void follow_weak_klass_links(); |
|
175 |
||
3696 | 176 |
// Class unloading. Clear weak refs in MDO's (ProfileData) |
177 |
// at the end of the marking phase. |
|
178 |
static void follow_mdo_weak_refs(); |
|
179 |
||
1 | 180 |
// Debugging |
181 |
static void trace(const char* msg) PRODUCT_RETURN; |
|
182 |
||
183 |
public: |
|
184 |
// Public closures |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
185 |
static FollowRootClosure follow_root_closure; |
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
670
diff
changeset
|
186 |
static CodeBlobToOopClosure follow_code_root_closure; // => follow_root_closure |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
187 |
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
|
188 |
static FollowStackClosure follow_stack_closure; |
1 | 189 |
static AdjustPointerClosure adjust_root_pointer_closure; |
190 |
static AdjustPointerClosure adjust_pointer_closure; |
|
191 |
||
192 |
// Reference Processing |
|
193 |
static ReferenceProcessor* const ref_processor() { return _ref_processor; } |
|
194 |
||
195 |
// Call backs for marking |
|
196 |
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
|
197 |
// 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
|
198 |
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
|
199 |
// 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
|
200 |
template <class T> static inline void mark_and_push(T* p); |
5076
8b74a4b60b31
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
3919
diff
changeset
|
201 |
static inline void push_objarray(oop obj, size_t index); |
1 | 202 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
203 |
static void follow_stack(); // Empty marking stack. |
1 | 204 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
205 |
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
|
206 |
// 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
|
207 |
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
|
208 |
static void restore_marks(); // Restore the marks that we saved in preserve_mark |
1 | 209 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
210 |
template <class T> static inline void adjust_pointer(T* p, bool isroot); |
1 | 211 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
212 |
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
|
213 |
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
|
214 |
static void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); } |
1 | 215 |
|
216 |
#ifdef VALIDATE_MARK_SWEEP |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
217 |
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
|
218 |
static void check_adjust_pointer(void* p); |
1 | 219 |
static void track_interior_pointers(oop obj); |
220 |
static void check_interior_pointers(); |
|
221 |
||
222 |
static void reset_live_oop_tracking(bool at_perm); |
|
223 |
static void register_live_oop(oop p, size_t size); |
|
224 |
static void validate_live_oop(oop p, size_t size); |
|
225 |
static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top); |
|
226 |
static void compaction_complete(); |
|
227 |
||
228 |
// Querying operation of RecordMarkSweepCompaction results. |
|
229 |
// Finds and prints the current base oop and offset for a word |
|
230 |
// within an oop that was live during the last GC. Helpful for |
|
231 |
// tracking down heap stomps. |
|
232 |
static void print_new_location_of_heap_address(HeapWord* q); |
|
233 |
#endif |
|
234 |
||
235 |
// Call backs for class unloading |
|
3696 | 236 |
// Update subklass/sibling/implementor links at end of marking. |
237 |
static void revisit_weak_klass_link(Klass* k); |
|
238 |
// For weak refs clearing in MDO's |
|
239 |
static void revisit_mdo(DataLayout* p); |
|
1 | 240 |
}; |
241 |
||
242 |
class PreservedMark VALUE_OBJ_CLASS_SPEC { |
|
243 |
private: |
|
244 |
oop _obj; |
|
245 |
markOop _mark; |
|
246 |
||
247 |
public: |
|
248 |
void init(oop obj, markOop mark) { |
|
249 |
_obj = obj; |
|
250 |
_mark = mark; |
|
251 |
} |
|
252 |
||
253 |
void adjust_pointer() { |
|
254 |
MarkSweep::adjust_pointer(&_obj); |
|
255 |
} |
|
256 |
||
257 |
void restore() { |
|
258 |
_obj->set_mark(_mark); |
|
259 |
} |
|
260 |
}; |
|
7397 | 261 |
|
262 |
#endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_MARKSWEEP_HPP |