Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/shared/markSweep.hpp @ 6842:b9a9ed0f8eeb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7197424: update copyright year to match last edit in jdk8 hotspot repository Summary: Update copyright year to 2012 for relevant files Reviewed-by: dholmes, coleenp
author mikael
date Tue, 09 Oct 2012 10:09:34 -0700
parents da91efe96a93
children b735136e0d82
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1311
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1311
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1311
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_MARKSWEEP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_MARKSWEEP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
28 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
29 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
30 #include "oops/markOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
31 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
32 #include "runtime/timer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
33 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
34 #include "utilities/stack.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
35 #include "utilities/taskqueue.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
36
0
a61af66fc99e Initial load
duke
parents:
diff changeset
37 class ReferenceProcessor;
941
8b46c4d82093 4957990: Perm heap bloat in JVM
ysr
parents: 196
diff changeset
38 class DataLayout;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
39
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // MarkSweep takes care of global mark-compact garbage collection for a
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // GenCollectedHeap using a four-phase pointer forwarding algorithm. All
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // generations are assumed to support marking; those that can also support
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // compaction.
a61af66fc99e Initial load
duke
parents:
diff changeset
44 //
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // Class unloading will only occur when a full gc is invoked.
a61af66fc99e Initial load
duke
parents:
diff changeset
46
a61af66fc99e Initial load
duke
parents:
diff changeset
47 // If VALIDATE_MARK_SWEEP is defined, the -XX:+ValidateMarkSweep flag will
a61af66fc99e Initial load
duke
parents:
diff changeset
48 // be operational, and will provide slow but comprehensive self-checks within
a61af66fc99e Initial load
duke
parents:
diff changeset
49 // the GC. This is not enabled by default in product or release builds,
a61af66fc99e Initial load
duke
parents:
diff changeset
50 // since the extra call to track_adjusted_pointer() in _adjust_pointer()
a61af66fc99e Initial load
duke
parents:
diff changeset
51 // would be too much overhead, and would disturb performance measurement.
a61af66fc99e Initial load
duke
parents:
diff changeset
52 // However, debug builds are sometimes way too slow to run GC tests!
a61af66fc99e Initial load
duke
parents:
diff changeset
53 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
54 #define VALIDATE_MARK_SWEEP 1
a61af66fc99e Initial load
duke
parents:
diff changeset
55 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
56 #ifdef VALIDATE_MARK_SWEEP
a61af66fc99e Initial load
duke
parents:
diff changeset
57 #define VALIDATE_MARK_SWEEP_ONLY(code) code
a61af66fc99e Initial load
duke
parents:
diff changeset
58 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
59 #define VALIDATE_MARK_SWEEP_ONLY(code)
a61af66fc99e Initial load
duke
parents:
diff changeset
60 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
61
a61af66fc99e Initial load
duke
parents:
diff changeset
62 // declared at end
a61af66fc99e Initial load
duke
parents:
diff changeset
63 class PreservedMark;
a61af66fc99e Initial load
duke
parents:
diff changeset
64
a61af66fc99e Initial load
duke
parents:
diff changeset
65 class MarkSweep : AllStatic {
a61af66fc99e Initial load
duke
parents:
diff changeset
66 //
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
67 // Inline closure decls
0
a61af66fc99e Initial load
duke
parents:
diff changeset
68 //
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
69 class FollowRootClosure: public OopsInGenClosure {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
70 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
71 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
72 virtual void do_oop(narrowOop* p);
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 MarkAndPushClosure: public OopClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
76 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
77 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
78 virtual void do_oop(narrowOop* p);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
79 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
80
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
81 // The one and only place to start following the classes.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
82 // Should only be applied to the ClassLoaderData klasses list.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
83 class FollowKlassClosure : public KlassClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
84 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
85 void do_klass(Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
86 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
87 class AdjustKlassClosure : public KlassClosure {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
88 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
89 void do_klass(Klass* klass);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
90 };
a61af66fc99e Initial load
duke
parents:
diff changeset
91
a61af66fc99e Initial load
duke
parents:
diff changeset
92 class FollowStackClosure: public VoidClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
93 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
94 virtual void do_void();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
95 };
a61af66fc99e Initial load
duke
parents:
diff changeset
96
a61af66fc99e Initial load
duke
parents:
diff changeset
97 class AdjustPointerClosure: public OopsInGenClosure {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
98 private:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
99 bool _is_root;
a61af66fc99e Initial load
duke
parents:
diff changeset
100 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
101 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
102 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
103 virtual void do_oop(narrowOop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
104 };
a61af66fc99e Initial load
duke
parents:
diff changeset
105
a61af66fc99e Initial load
duke
parents:
diff changeset
106 // Used for java/lang/ref handling
a61af66fc99e Initial load
duke
parents:
diff changeset
107 class IsAliveClosure: public BoolObjectClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
108 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
109 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
110 virtual bool do_object_b(oop p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
111 };
a61af66fc99e Initial load
duke
parents:
diff changeset
112
a61af66fc99e Initial load
duke
parents:
diff changeset
113 class KeepAliveClosure: public OopClosure {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
114 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
115 template <class T> void do_oop_work(T* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
116 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
117 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
118 virtual void do_oop(narrowOop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
119 };
a61af66fc99e Initial load
duke
parents:
diff changeset
120
a61af66fc99e Initial load
duke
parents:
diff changeset
121 //
a61af66fc99e Initial load
duke
parents:
diff changeset
122 // Friend decls
a61af66fc99e Initial load
duke
parents:
diff changeset
123 //
a61af66fc99e Initial load
duke
parents:
diff changeset
124 friend class AdjustPointerClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
125 friend class KeepAliveClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
126 friend class VM_MarkSweep;
a61af66fc99e Initial load
duke
parents:
diff changeset
127 friend void marksweep_init();
a61af66fc99e Initial load
duke
parents:
diff changeset
128
a61af66fc99e Initial load
duke
parents:
diff changeset
129 //
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // Vars
a61af66fc99e Initial load
duke
parents:
diff changeset
131 //
a61af66fc99e Initial load
duke
parents:
diff changeset
132 protected:
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
133 // Total invocations of a MarkSweep collection
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
134 static unsigned int _total_invocations;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
135
1311
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 1000
diff changeset
136 // Traversal stacks used during phase1
6197
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 4099
diff changeset
137 static Stack<oop, mtGC> _marking_stack;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 4099
diff changeset
138 static Stack<ObjArrayTask, mtGC> _objarray_stack;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
139
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // Space for storing/restoring mark word
6197
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 4099
diff changeset
141 static Stack<markOop, mtGC> _preserved_mark_stack;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 4099
diff changeset
142 static Stack<oop, mtGC> _preserved_oop_stack;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
143 static size_t _preserved_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
144 static size_t _preserved_count_max;
a61af66fc99e Initial load
duke
parents:
diff changeset
145 static PreservedMark* _preserved_marks;
a61af66fc99e Initial load
duke
parents:
diff changeset
146
a61af66fc99e Initial load
duke
parents:
diff changeset
147 // Reference processing (used in ...follow_contents)
a61af66fc99e Initial load
duke
parents:
diff changeset
148 static ReferenceProcessor* _ref_processor;
a61af66fc99e Initial load
duke
parents:
diff changeset
149
a61af66fc99e Initial load
duke
parents:
diff changeset
150 #ifdef VALIDATE_MARK_SWEEP
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
151 static GrowableArray<void*>* _root_refs_stack;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
152 static GrowableArray<oop> * _live_oops;
a61af66fc99e Initial load
duke
parents:
diff changeset
153 static GrowableArray<oop> * _live_oops_moved_to;
a61af66fc99e Initial load
duke
parents:
diff changeset
154 static GrowableArray<size_t>* _live_oops_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
155 static size_t _live_oops_index;
a61af66fc99e Initial load
duke
parents:
diff changeset
156 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
157 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
158 static GrowableArray<void*>* _adjusted_pointers;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
159 static bool _pointer_tracking;
a61af66fc99e Initial load
duke
parents:
diff changeset
160 static bool _root_tracking;
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // The following arrays are saved since the time of the last GC and
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // assist in tracking down problems where someone has done an errant
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // store into the heap, usually to an oop that wasn't properly
a61af66fc99e Initial load
duke
parents:
diff changeset
165 // handleized across a GC. If we crash or otherwise fail before the
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // next GC, we can query these arrays to find out the object we had
a61af66fc99e Initial load
duke
parents:
diff changeset
167 // intended to do the store to (assuming it is still alive) and the
a61af66fc99e Initial load
duke
parents:
diff changeset
168 // offset within that object. Covered under RecordMarkSweepCompaction.
a61af66fc99e Initial load
duke
parents:
diff changeset
169 static GrowableArray<HeapWord*> * _cur_gc_live_oops;
a61af66fc99e Initial load
duke
parents:
diff changeset
170 static GrowableArray<HeapWord*> * _cur_gc_live_oops_moved_to;
a61af66fc99e Initial load
duke
parents:
diff changeset
171 static GrowableArray<size_t>* _cur_gc_live_oops_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
172 static GrowableArray<HeapWord*> * _last_gc_live_oops;
a61af66fc99e Initial load
duke
parents:
diff changeset
173 static GrowableArray<HeapWord*> * _last_gc_live_oops_moved_to;
a61af66fc99e Initial load
duke
parents:
diff changeset
174 static GrowableArray<size_t>* _last_gc_live_oops_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
175 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
176
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // Non public closures
a61af66fc99e Initial load
duke
parents:
diff changeset
178 static KeepAliveClosure keep_alive;
a61af66fc99e Initial load
duke
parents:
diff changeset
179
a61af66fc99e Initial load
duke
parents:
diff changeset
180 // Debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
181 static void trace(const char* msg) PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
182
a61af66fc99e Initial load
duke
parents:
diff changeset
183 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
184 // Public closures
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
185 static IsAliveClosure is_alive;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
186 static FollowRootClosure follow_root_closure;
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 196
diff changeset
187 static CodeBlobToOopClosure follow_code_root_closure; // => follow_root_closure
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
188 static MarkAndPushClosure mark_and_push_closure;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
189 static FollowKlassClosure follow_klass_closure;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
190 static FollowStackClosure follow_stack_closure;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
191 static AdjustPointerClosure adjust_root_pointer_closure;
a61af66fc99e Initial load
duke
parents:
diff changeset
192 static AdjustPointerClosure adjust_pointer_closure;
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
193 static AdjustKlassClosure adjust_klass_closure;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
194
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
195 // Accessors
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
196 static unsigned int total_invocations() { return _total_invocations; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 // Reference Processing
a61af66fc99e Initial load
duke
parents:
diff changeset
199 static ReferenceProcessor* const ref_processor() { return _ref_processor; }
a61af66fc99e Initial load
duke
parents:
diff changeset
200
a61af66fc99e Initial load
duke
parents:
diff changeset
201 // Call backs for marking
a61af66fc99e Initial load
duke
parents:
diff changeset
202 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
203 // 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
204 template <class T> static inline void follow_root(T* p);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
205
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
206 // Check mark and maybe push on marking stack
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
207 template <class T> static void mark_and_push(T* p);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
208
1311
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 1000
diff changeset
209 static inline void push_objarray(oop obj, size_t index);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
210
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
211 static void follow_stack(); // Empty marking stack.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
212
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
213 static void follow_klass(Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
214 static void adjust_klass(Klass* klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
215
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
216 static void follow_class_loader(ClassLoaderData* cld);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
217 static void adjust_class_loader(ClassLoaderData* cld);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
218
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
219 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
220 // 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
221 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
222 static void restore_marks(); // Restore the marks that we saved in preserve_mark
0
a61af66fc99e Initial load
duke
parents:
diff changeset
223
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
224 template <class T> static inline void adjust_pointer(T* p, bool isroot);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
225
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
226 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
227 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
228 static void adjust_pointer(narrowOop* p) { adjust_pointer(p, false); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
229
a61af66fc99e Initial load
duke
parents:
diff changeset
230 #ifdef VALIDATE_MARK_SWEEP
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
231 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
232 static void check_adjust_pointer(void* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
233 static void track_interior_pointers(oop obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
234 static void check_interior_pointers();
a61af66fc99e Initial load
duke
parents:
diff changeset
235
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6197
diff changeset
236 static void reset_live_oop_tracking();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
237 static void register_live_oop(oop p, size_t size);
a61af66fc99e Initial load
duke
parents:
diff changeset
238 static void validate_live_oop(oop p, size_t size);
a61af66fc99e Initial load
duke
parents:
diff changeset
239 static void live_oop_moved_to(HeapWord* q, size_t size, HeapWord* compaction_top);
a61af66fc99e Initial load
duke
parents:
diff changeset
240 static void compaction_complete();
a61af66fc99e Initial load
duke
parents:
diff changeset
241
a61af66fc99e Initial load
duke
parents:
diff changeset
242 // Querying operation of RecordMarkSweepCompaction results.
a61af66fc99e Initial load
duke
parents:
diff changeset
243 // Finds and prints the current base oop and offset for a word
a61af66fc99e Initial load
duke
parents:
diff changeset
244 // within an oop that was live during the last GC. Helpful for
a61af66fc99e Initial load
duke
parents:
diff changeset
245 // tracking down heap stomps.
a61af66fc99e Initial load
duke
parents:
diff changeset
246 static void print_new_location_of_heap_address(HeapWord* q);
a61af66fc99e Initial load
duke
parents:
diff changeset
247 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
248 };
a61af66fc99e Initial load
duke
parents:
diff changeset
249
a61af66fc99e Initial load
duke
parents:
diff changeset
250 class PreservedMark VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load
duke
parents:
diff changeset
251 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
252 oop _obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
253 markOop _mark;
a61af66fc99e Initial load
duke
parents:
diff changeset
254
a61af66fc99e Initial load
duke
parents:
diff changeset
255 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
256 void init(oop obj, markOop mark) {
a61af66fc99e Initial load
duke
parents:
diff changeset
257 _obj = obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
258 _mark = mark;
a61af66fc99e Initial load
duke
parents:
diff changeset
259 }
a61af66fc99e Initial load
duke
parents:
diff changeset
260
a61af66fc99e Initial load
duke
parents:
diff changeset
261 void adjust_pointer() {
a61af66fc99e Initial load
duke
parents:
diff changeset
262 MarkSweep::adjust_pointer(&_obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
263 }
a61af66fc99e Initial load
duke
parents:
diff changeset
264
a61af66fc99e Initial load
duke
parents:
diff changeset
265 void restore() {
a61af66fc99e Initial load
duke
parents:
diff changeset
266 _obj->set_mark(_mark);
a61af66fc99e Initial load
duke
parents:
diff changeset
267 }
a61af66fc99e Initial load
duke
parents:
diff changeset
268 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
269
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1836
diff changeset
270 #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_MARKSWEEP_HPP