44 #define VALIDATE_MARK_SWEEP_ONLY(code) code |
44 #define VALIDATE_MARK_SWEEP_ONLY(code) code |
45 #else |
45 #else |
46 #define VALIDATE_MARK_SWEEP_ONLY(code) |
46 #define VALIDATE_MARK_SWEEP_ONLY(code) |
47 #endif |
47 #endif |
48 |
48 |
49 |
|
50 // declared at end |
49 // declared at end |
51 class PreservedMark; |
50 class PreservedMark; |
52 |
51 |
53 class MarkSweep : AllStatic { |
52 class MarkSweep : AllStatic { |
54 // |
53 // |
55 // In line closure decls |
54 // Inline closure decls |
56 // |
55 // |
57 |
56 class FollowRootClosure: public OopsInGenClosure { |
58 class FollowRootClosure: public OopsInGenClosure{ |
57 public: |
59 public: |
58 virtual void do_oop(oop* p); |
60 void do_oop(oop* p) { follow_root(p); } |
59 virtual void do_oop(narrowOop* p); |
61 virtual const bool do_nmethods() const { return true; } |
60 virtual const bool do_nmethods() const { return true; } |
62 }; |
61 }; |
63 |
62 |
64 class MarkAndPushClosure: public OopClosure { |
63 class MarkAndPushClosure: public OopClosure { |
65 public: |
64 public: |
66 void do_oop(oop* p) { mark_and_push(p); } |
65 virtual void do_oop(oop* p); |
|
66 virtual void do_oop(narrowOop* p); |
67 virtual const bool do_nmethods() const { return true; } |
67 virtual const bool do_nmethods() const { return true; } |
68 }; |
68 }; |
69 |
69 |
70 class FollowStackClosure: public VoidClosure { |
70 class FollowStackClosure: public VoidClosure { |
71 public: |
71 public: |
72 void do_void() { follow_stack(); } |
72 virtual void do_void(); |
73 }; |
73 }; |
74 |
74 |
75 class AdjustPointerClosure: public OopsInGenClosure { |
75 class AdjustPointerClosure: public OopsInGenClosure { |
|
76 private: |
76 bool _is_root; |
77 bool _is_root; |
77 public: |
78 public: |
78 AdjustPointerClosure(bool is_root) : _is_root(is_root) {} |
79 AdjustPointerClosure(bool is_root) : _is_root(is_root) {} |
79 void do_oop(oop* p) { _adjust_pointer(p, _is_root); } |
80 virtual void do_oop(oop* p); |
|
81 virtual void do_oop(narrowOop* p); |
80 }; |
82 }; |
81 |
83 |
82 // Used for java/lang/ref handling |
84 // Used for java/lang/ref handling |
83 class IsAliveClosure: public BoolObjectClosure { |
85 class IsAliveClosure: public BoolObjectClosure { |
84 public: |
86 public: |
85 void do_object(oop p) { assert(false, "don't call"); } |
87 virtual void do_object(oop p); |
86 bool do_object_b(oop p) { return p->is_gc_marked(); } |
88 virtual bool do_object_b(oop p); |
87 }; |
89 }; |
88 |
90 |
89 class KeepAliveClosure: public OopClosure { |
91 class KeepAliveClosure: public OopClosure { |
90 public: |
92 protected: |
91 void do_oop(oop* p); |
93 template <class T> void do_oop_work(T* p); |
|
94 public: |
|
95 virtual void do_oop(oop* p); |
|
96 virtual void do_oop(narrowOop* p); |
92 }; |
97 }; |
93 |
98 |
94 // |
99 // |
95 // Friend decls |
100 // Friend decls |
96 // |
101 // |
97 |
|
98 friend class AdjustPointerClosure; |
102 friend class AdjustPointerClosure; |
99 friend class KeepAliveClosure; |
103 friend class KeepAliveClosure; |
100 friend class VM_MarkSweep; |
104 friend class VM_MarkSweep; |
101 friend void marksweep_init(); |
105 friend void marksweep_init(); |
102 |
106 |
118 |
122 |
119 // Reference processing (used in ...follow_contents) |
123 // Reference processing (used in ...follow_contents) |
120 static ReferenceProcessor* _ref_processor; |
124 static ReferenceProcessor* _ref_processor; |
121 |
125 |
122 #ifdef VALIDATE_MARK_SWEEP |
126 #ifdef VALIDATE_MARK_SWEEP |
123 static GrowableArray<oop*>* _root_refs_stack; |
127 static GrowableArray<void*>* _root_refs_stack; |
124 static GrowableArray<oop> * _live_oops; |
128 static GrowableArray<oop> * _live_oops; |
125 static GrowableArray<oop> * _live_oops_moved_to; |
129 static GrowableArray<oop> * _live_oops_moved_to; |
126 static GrowableArray<size_t>* _live_oops_size; |
130 static GrowableArray<size_t>* _live_oops_size; |
127 static size_t _live_oops_index; |
131 static size_t _live_oops_index; |
128 static size_t _live_oops_index_at_perm; |
132 static size_t _live_oops_index_at_perm; |
129 static GrowableArray<oop*>* _other_refs_stack; |
133 static GrowableArray<void*>* _other_refs_stack; |
130 static GrowableArray<oop*>* _adjusted_pointers; |
134 static GrowableArray<void*>* _adjusted_pointers; |
131 static bool _pointer_tracking; |
135 static bool _pointer_tracking; |
132 static bool _root_tracking; |
136 static bool _root_tracking; |
133 |
137 |
134 // The following arrays are saved since the time of the last GC and |
138 // The following arrays are saved since the time of the last GC and |
135 // assist in tracking down problems where someone has done an errant |
139 // assist in tracking down problems where someone has done an errant |
144 static GrowableArray<HeapWord*> * _last_gc_live_oops; |
148 static GrowableArray<HeapWord*> * _last_gc_live_oops; |
145 static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to; |
149 static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to; |
146 static GrowableArray<size_t>* _last_gc_live_oops_size; |
150 static GrowableArray<size_t>* _last_gc_live_oops_size; |
147 #endif |
151 #endif |
148 |
152 |
149 |
|
150 // Non public closures |
153 // Non public closures |
151 static IsAliveClosure is_alive; |
154 static IsAliveClosure is_alive; |
152 static KeepAliveClosure keep_alive; |
155 static KeepAliveClosure keep_alive; |
153 |
156 |
154 // Class unloading. Update subklass/sibling/implementor links at end of marking phase. |
157 // Class unloading. Update subklass/sibling/implementor links at end of marking phase. |
155 static void follow_weak_klass_links(); |
158 static void follow_weak_klass_links(); |
156 |
159 |
157 // Debugging |
160 // Debugging |
158 static void trace(const char* msg) PRODUCT_RETURN; |
161 static void trace(const char* msg) PRODUCT_RETURN; |
159 |
162 |
160 public: |
163 public: |
161 // Public closures |
164 // Public closures |
162 static FollowRootClosure follow_root_closure; |
165 static FollowRootClosure follow_root_closure; |
163 static MarkAndPushClosure mark_and_push_closure; |
166 static MarkAndPushClosure mark_and_push_closure; |
164 static FollowStackClosure follow_stack_closure; |
167 static FollowStackClosure follow_stack_closure; |
165 static AdjustPointerClosure adjust_root_pointer_closure; |
168 static AdjustPointerClosure adjust_root_pointer_closure; |
166 static AdjustPointerClosure adjust_pointer_closure; |
169 static AdjustPointerClosure adjust_pointer_closure; |
167 |
170 |
168 // Reference Processing |
171 // Reference Processing |
169 static ReferenceProcessor* const ref_processor() { return _ref_processor; } |
172 static ReferenceProcessor* const ref_processor() { return _ref_processor; } |
170 |
173 |
171 // Call backs for marking |
174 // Call backs for marking |
172 static void mark_object(oop obj); |
175 static void mark_object(oop obj); |
173 static void follow_root(oop* p); // Mark pointer and follow contents. Empty marking |
176 // Mark pointer and follow contents. Empty marking stack afterwards. |
174 |
177 template <class T> static inline void follow_root(T* p); |
175 // stack afterwards. |
178 // Mark pointer and follow contents. |
176 |
179 template <class T> static inline void mark_and_follow(T* p); |
177 static void mark_and_follow(oop* p); // Mark pointer and follow contents. |
180 // Check mark and maybe push on marking stack |
178 static void _mark_and_push(oop* p); // Mark pointer and push obj on |
181 template <class T> static inline void mark_and_push(T* p); |
179 // marking stack. |
182 |
180 |
183 static void follow_stack(); // Empty marking stack. |
181 |
184 |
182 static void mark_and_push(oop* p) { // Check mark and maybe push on |
185 static void preserve_mark(oop p, markOop mark); |
183 // marking stack |
186 // Save the mark word so it can be restored later |
184 // assert(Universe::is_reserved_heap((oop)p), "we should only be traversing objects here"); |
187 static void adjust_marks(); // Adjust the pointers in the preserved marks table |
185 oop m = *p; |
188 static void restore_marks(); // Restore the marks that we saved in preserve_mark |
186 if (m != NULL && !m->mark()->is_marked()) { |
189 |
187 _mark_and_push(p); |
190 template <class T> static inline void adjust_pointer(T* p, bool isroot); |
188 } |
191 |
189 } |
192 static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); } |
190 |
193 static void adjust_pointer(oop* p) { adjust_pointer(p, false); } |
191 static void follow_stack(); // Empty marking stack. |
194 static void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); } |
192 |
|
193 |
|
194 static void preserve_mark(oop p, markOop mark); // Save the mark word so it can be restored later |
|
195 static void adjust_marks(); // Adjust the pointers in the preserved marks table |
|
196 static void restore_marks(); // Restore the marks that we saved in preserve_mark |
|
197 |
|
198 static void _adjust_pointer(oop* p, bool isroot); |
|
199 |
|
200 static void adjust_root_pointer(oop* p) { _adjust_pointer(p, true); } |
|
201 static void adjust_pointer(oop* p) { _adjust_pointer(p, false); } |
|
202 |
195 |
203 #ifdef VALIDATE_MARK_SWEEP |
196 #ifdef VALIDATE_MARK_SWEEP |
204 static void track_adjusted_pointer(oop* p, oop newobj, bool isroot); |
197 static void track_adjusted_pointer(void* p, bool isroot); |
205 static void check_adjust_pointer(oop* p); // Adjust this pointer |
198 static void check_adjust_pointer(void* p); |
206 static void track_interior_pointers(oop obj); |
199 static void track_interior_pointers(oop obj); |
207 static void check_interior_pointers(); |
200 static void check_interior_pointers(); |
208 |
201 |
209 static void reset_live_oop_tracking(bool at_perm); |
202 static void reset_live_oop_tracking(bool at_perm); |
210 static void register_live_oop(oop p, size_t size); |
203 static void register_live_oop(oop p, size_t size); |