annotate src/share/vm/gc_implementation/shared/markSweep.hpp @ 452:00b023ae2d78

6722113: CMS: Incorrect overflow handling during precleaning of Reference lists Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery. Reviewed-by: apetrusenko, jcoomes
author ysr
date Thu, 20 Nov 2008 12:27:41 -0800
parents d1605aabd0a1
children 8b46c4d82093 148e5441d916
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
196
d1605aabd0a1 6719955: Update copyright year
xdono
parents: 113
diff changeset
2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 class ReferenceProcessor;
a61af66fc99e Initial load
duke
parents:
diff changeset
26
a61af66fc99e Initial load
duke
parents:
diff changeset
27 // MarkSweep takes care of global mark-compact garbage collection for a
a61af66fc99e Initial load
duke
parents:
diff changeset
28 // GenCollectedHeap using a four-phase pointer forwarding algorithm. All
a61af66fc99e Initial load
duke
parents:
diff changeset
29 // generations are assumed to support marking; those that can also support
a61af66fc99e Initial load
duke
parents:
diff changeset
30 // compaction.
a61af66fc99e Initial load
duke
parents:
diff changeset
31 //
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // Class unloading will only occur when a full gc is invoked.
a61af66fc99e Initial load
duke
parents:
diff changeset
33
a61af66fc99e Initial load
duke
parents:
diff changeset
34 // If VALIDATE_MARK_SWEEP is defined, the -XX:+ValidateMarkSweep flag will
a61af66fc99e Initial load
duke
parents:
diff changeset
35 // be operational, and will provide slow but comprehensive self-checks within
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // the GC. This is not enabled by default in product or release builds,
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // since the extra call to track_adjusted_pointer() in _adjust_pointer()
a61af66fc99e Initial load
duke
parents:
diff changeset
38 // would be too much overhead, and would disturb performance measurement.
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // However, debug builds are sometimes way too slow to run GC tests!
a61af66fc99e Initial load
duke
parents:
diff changeset
40 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
41 #define VALIDATE_MARK_SWEEP 1
a61af66fc99e Initial load
duke
parents:
diff changeset
42 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
43 #ifdef VALIDATE_MARK_SWEEP
a61af66fc99e Initial load
duke
parents:
diff changeset
44 #define VALIDATE_MARK_SWEEP_ONLY(code) code
a61af66fc99e Initial load
duke
parents:
diff changeset
45 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
46 #define VALIDATE_MARK_SWEEP_ONLY(code)
a61af66fc99e Initial load
duke
parents:
diff changeset
47 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
48
a61af66fc99e Initial load
duke
parents:
diff changeset
49 // declared at end
a61af66fc99e Initial load
duke
parents:
diff changeset
50 class PreservedMark;
a61af66fc99e Initial load
duke
parents:
diff changeset
51
a61af66fc99e Initial load
duke
parents:
diff changeset
52 class MarkSweep : AllStatic {
a61af66fc99e Initial load
duke
parents:
diff changeset
53 //
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
54 // Inline closure decls
0
a61af66fc99e Initial load
duke
parents:
diff changeset
55 //
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
56 class FollowRootClosure: public OopsInGenClosure {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
57 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
58 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
59 virtual void do_oop(narrowOop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
60 virtual const bool do_nmethods() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
61 };
a61af66fc99e Initial load
duke
parents:
diff changeset
62
a61af66fc99e Initial load
duke
parents:
diff changeset
63 class MarkAndPushClosure: public OopClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
64 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
65 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
66 virtual void do_oop(narrowOop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
67 virtual const bool do_nmethods() const { return true; }
a61af66fc99e Initial load
duke
parents:
diff changeset
68 };
a61af66fc99e Initial load
duke
parents:
diff changeset
69
a61af66fc99e Initial load
duke
parents:
diff changeset
70 class FollowStackClosure: public VoidClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
71 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
72 virtual void do_void();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
73 };
a61af66fc99e Initial load
duke
parents:
diff changeset
74
a61af66fc99e Initial load
duke
parents:
diff changeset
75 class AdjustPointerClosure: public OopsInGenClosure {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
76 private:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
77 bool _is_root;
a61af66fc99e Initial load
duke
parents:
diff changeset
78 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
79 AdjustPointerClosure(bool is_root) : _is_root(is_root) {}
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
80 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
81 virtual void do_oop(narrowOop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
82 };
a61af66fc99e Initial load
duke
parents:
diff changeset
83
a61af66fc99e Initial load
duke
parents:
diff changeset
84 // Used for java/lang/ref handling
a61af66fc99e Initial load
duke
parents:
diff changeset
85 class IsAliveClosure: public BoolObjectClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
86 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
87 virtual void do_object(oop p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
88 virtual bool do_object_b(oop p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
89 };
a61af66fc99e Initial load
duke
parents:
diff changeset
90
a61af66fc99e Initial load
duke
parents:
diff changeset
91 class KeepAliveClosure: public OopClosure {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
92 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
93 template <class T> void do_oop_work(T* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
94 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
95 virtual void do_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
96 virtual void do_oop(narrowOop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
97 };
a61af66fc99e Initial load
duke
parents:
diff changeset
98
a61af66fc99e Initial load
duke
parents:
diff changeset
99 //
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // Friend decls
a61af66fc99e Initial load
duke
parents:
diff changeset
101 //
a61af66fc99e Initial load
duke
parents:
diff changeset
102 friend class AdjustPointerClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
103 friend class KeepAliveClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
104 friend class VM_MarkSweep;
a61af66fc99e Initial load
duke
parents:
diff changeset
105 friend void marksweep_init();
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 //
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // Vars
a61af66fc99e Initial load
duke
parents:
diff changeset
109 //
a61af66fc99e Initial load
duke
parents:
diff changeset
110 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // Traversal stack used during phase1
a61af66fc99e Initial load
duke
parents:
diff changeset
112 static GrowableArray<oop>* _marking_stack;
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // Stack for live klasses to revisit at end of marking phase
a61af66fc99e Initial load
duke
parents:
diff changeset
114 static GrowableArray<Klass*>* _revisit_klass_stack;
a61af66fc99e Initial load
duke
parents:
diff changeset
115
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // Space for storing/restoring mark word
a61af66fc99e Initial load
duke
parents:
diff changeset
117 static GrowableArray<markOop>* _preserved_mark_stack;
a61af66fc99e Initial load
duke
parents:
diff changeset
118 static GrowableArray<oop>* _preserved_oop_stack;
a61af66fc99e Initial load
duke
parents:
diff changeset
119 static size_t _preserved_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
120 static size_t _preserved_count_max;
a61af66fc99e Initial load
duke
parents:
diff changeset
121 static PreservedMark* _preserved_marks;
a61af66fc99e Initial load
duke
parents:
diff changeset
122
a61af66fc99e Initial load
duke
parents:
diff changeset
123 // Reference processing (used in ...follow_contents)
a61af66fc99e Initial load
duke
parents:
diff changeset
124 static ReferenceProcessor* _ref_processor;
a61af66fc99e Initial load
duke
parents:
diff changeset
125
a61af66fc99e Initial load
duke
parents:
diff changeset
126 #ifdef VALIDATE_MARK_SWEEP
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
127 static GrowableArray<void*>* _root_refs_stack;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
128 static GrowableArray<oop> * _live_oops;
a61af66fc99e Initial load
duke
parents:
diff changeset
129 static GrowableArray<oop> * _live_oops_moved_to;
a61af66fc99e Initial load
duke
parents:
diff changeset
130 static GrowableArray<size_t>* _live_oops_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
131 static size_t _live_oops_index;
a61af66fc99e Initial load
duke
parents:
diff changeset
132 static size_t _live_oops_index_at_perm;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
133 static GrowableArray<void*>* _other_refs_stack;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
134 static GrowableArray<void*>* _adjusted_pointers;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
135 static bool _pointer_tracking;
a61af66fc99e Initial load
duke
parents:
diff changeset
136 static bool _root_tracking;
a61af66fc99e Initial load
duke
parents:
diff changeset
137
a61af66fc99e Initial load
duke
parents:
diff changeset
138 // The following arrays are saved since the time of the last GC and
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // assist in tracking down problems where someone has done an errant
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // store into the heap, usually to an oop that wasn't properly
a61af66fc99e Initial load
duke
parents:
diff changeset
141 // handleized across a GC. If we crash or otherwise fail before the
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // next GC, we can query these arrays to find out the object we had
a61af66fc99e Initial load
duke
parents:
diff changeset
143 // intended to do the store to (assuming it is still alive) and the
a61af66fc99e Initial load
duke
parents:
diff changeset
144 // offset within that object. Covered under RecordMarkSweepCompaction.
a61af66fc99e Initial load
duke
parents:
diff changeset
145 static GrowableArray<HeapWord*> * _cur_gc_live_oops;
a61af66fc99e Initial load
duke
parents:
diff changeset
146 static GrowableArray<HeapWord*> * _cur_gc_live_oops_moved_to;
a61af66fc99e Initial load
duke
parents:
diff changeset
147 static GrowableArray<size_t>* _cur_gc_live_oops_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
148 static GrowableArray<HeapWord*> * _last_gc_live_oops;
a61af66fc99e Initial load
duke
parents:
diff changeset
149 static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to;
a61af66fc99e Initial load
duke
parents:
diff changeset
150 static GrowableArray<size_t>* _last_gc_live_oops_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
151 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
152
a61af66fc99e Initial load
duke
parents:
diff changeset
153 // Non public closures
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
154 static IsAliveClosure is_alive;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
155 static KeepAliveClosure keep_alive;
a61af66fc99e Initial load
duke
parents:
diff changeset
156
a61af66fc99e Initial load
duke
parents:
diff changeset
157 // Class unloading. Update subklass/sibling/implementor links at end of marking phase.
a61af66fc99e Initial load
duke
parents:
diff changeset
158 static void follow_weak_klass_links();
a61af66fc99e Initial load
duke
parents:
diff changeset
159
a61af66fc99e Initial load
duke
parents:
diff changeset
160 // Debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
161 static void trace(const char* msg) PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
162
a61af66fc99e Initial load
duke
parents:
diff changeset
163 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // Public closures
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
165 static FollowRootClosure follow_root_closure;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
166 static MarkAndPushClosure mark_and_push_closure;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
167 static FollowStackClosure follow_stack_closure;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
168 static AdjustPointerClosure adjust_root_pointer_closure;
a61af66fc99e Initial load
duke
parents:
diff changeset
169 static AdjustPointerClosure adjust_pointer_closure;
a61af66fc99e Initial load
duke
parents:
diff changeset
170
a61af66fc99e Initial load
duke
parents:
diff changeset
171 // Reference Processing
a61af66fc99e Initial load
duke
parents:
diff changeset
172 static ReferenceProcessor* const ref_processor() { return _ref_processor; }
a61af66fc99e Initial load
duke
parents:
diff changeset
173
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // Call backs for marking
a61af66fc99e Initial load
duke
parents:
diff changeset
175 static void mark_object(oop obj);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
176 // Mark pointer and follow contents. Empty marking stack afterwards.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
177 template <class T> static inline void follow_root(T* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
178 // Mark pointer and follow contents.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
179 template <class T> static inline void mark_and_follow(T* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
180 // Check mark and maybe push on marking stack
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
181 template <class T> static inline void mark_and_push(T* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
182
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
183 static void follow_stack(); // Empty marking stack.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
184
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
185 static void preserve_mark(oop p, markOop mark);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
186 // Save the mark word so it can be restored later
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
187 static void adjust_marks(); // Adjust the pointers in the preserved marks table
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
188 static void restore_marks(); // Restore the marks that we saved in preserve_mark
0
a61af66fc99e Initial load
duke
parents:
diff changeset
189
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
190 template <class T> static inline void adjust_pointer(T* p, bool isroot);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
191
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
192 static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
193 static void adjust_pointer(oop* p) { adjust_pointer(p, false); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
194 static void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
195
a61af66fc99e Initial load
duke
parents:
diff changeset
196 #ifdef VALIDATE_MARK_SWEEP
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
197 static void track_adjusted_pointer(void* p, bool isroot);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
198 static void check_adjust_pointer(void* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
199 static void track_interior_pointers(oop obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
200 static void check_interior_pointers();
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202 static void reset_live_oop_tracking(bool at_perm);
a61af66fc99e Initial load
duke
parents:
diff changeset
203 static void register_live_oop(oop p, size_t size);
a61af66fc99e Initial load
duke
parents:
diff changeset
204 static void validate_live_oop(oop p, size_t size);
a61af66fc99e Initial load
duke
parents:
diff changeset
205 static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top);
a61af66fc99e Initial load
duke
parents:
diff changeset
206 static void compaction_complete();
a61af66fc99e Initial load
duke
parents:
diff changeset
207
a61af66fc99e Initial load
duke
parents:
diff changeset
208 // Querying operation of RecordMarkSweepCompaction results.
a61af66fc99e Initial load
duke
parents:
diff changeset
209 // Finds and prints the current base oop and offset for a word
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // within an oop that was live during the last GC. Helpful for
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // tracking down heap stomps.
a61af66fc99e Initial load
duke
parents:
diff changeset
212 static void print_new_location_of_heap_address(HeapWord* q);
a61af66fc99e Initial load
duke
parents:
diff changeset
213 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
214
a61af66fc99e Initial load
duke
parents:
diff changeset
215 // Call backs for class unloading
a61af66fc99e Initial load
duke
parents:
diff changeset
216 static void revisit_weak_klass_link(Klass* k); // Update subklass/sibling/implementor links at end of marking.
a61af66fc99e Initial load
duke
parents:
diff changeset
217 };
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 class PreservedMark VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load
duke
parents:
diff changeset
220 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
221 oop _obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
222 markOop _mark;
a61af66fc99e Initial load
duke
parents:
diff changeset
223
a61af66fc99e Initial load
duke
parents:
diff changeset
224 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
225 void init(oop obj, markOop mark) {
a61af66fc99e Initial load
duke
parents:
diff changeset
226 _obj = obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
227 _mark = mark;
a61af66fc99e Initial load
duke
parents:
diff changeset
228 }
a61af66fc99e Initial load
duke
parents:
diff changeset
229
a61af66fc99e Initial load
duke
parents:
diff changeset
230 void adjust_pointer() {
a61af66fc99e Initial load
duke
parents:
diff changeset
231 MarkSweep::adjust_pointer(&_obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
232 }
a61af66fc99e Initial load
duke
parents:
diff changeset
233
a61af66fc99e Initial load
duke
parents:
diff changeset
234 void restore() {
a61af66fc99e Initial load
duke
parents:
diff changeset
235 _obj->set_mark(_mark);
a61af66fc99e Initial load
duke
parents:
diff changeset
236 }
a61af66fc99e Initial load
duke
parents:
diff changeset
237 };