17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "gc/parallel/gcTaskManager.hpp"
28 #include "gc/parallel/objectStartArray.hpp"
29 #include "gc/parallel/parMarkBitMap.inline.hpp"
30 #include "gc/parallel/parallelScavengeHeap.hpp"
31 #include "gc/parallel/psCompactionManager.inline.hpp"
32 #include "gc/parallel/psOldGen.hpp"
33 #include "gc/parallel/psParallelCompact.inline.hpp"
34 #include "gc/shared/taskqueue.inline.hpp"
35 #include "logging/log.hpp"
36 #include "memory/iterator.inline.hpp"
37 #include "oops/instanceKlass.inline.hpp"
38 #include "oops/instanceMirrorKlass.inline.hpp"
39 #include "oops/objArrayKlass.inline.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "runtime/atomic.hpp"
42
43 PSOldGen* ParCompactionManager::_old_gen = NULL;
44 ParCompactionManager** ParCompactionManager::_manager_array = NULL;
45
46 OopTaskQueueSet* ParCompactionManager::_stack_array = NULL;
47 ParCompactionManager::ObjArrayTaskQueueSet*
48 ParCompactionManager::_objarray_queues = NULL;
49 ObjectStartArray* ParCompactionManager::_start_array = NULL;
50 ParMarkBitMap* ParCompactionManager::_mark_bitmap = NULL;
51 RegionTaskQueueSet* ParCompactionManager::_region_array = NULL;
52
53 ParCompactionManager::ParCompactionManager() :
54 _action(CopyAndUpdate) {
55
56 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
165 // roots in Universe::oops_do.
166 assert(java_lang_Class::is_primitive(obj), "Sanity check");
167 }
168
169 ParCompactionManager::MarkAndPushClosure cl(cm);
170 oop_oop_iterate_statics<true>(obj, &cl);
171 }
172
173 void InstanceClassLoaderKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
174 InstanceKlass::oop_pc_follow_contents(obj, cm);
175
176 ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
177 if (loader_data != NULL) {
178 cm->follow_class_loader(loader_data);
179 }
180 }
181
182 template <class T>
183 static void oop_pc_follow_contents_specialized(InstanceRefKlass* klass, oop obj, ParCompactionManager* cm) {
184 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr_raw(obj);
185 T heap_oop = oopDesc::load_heap_oop(referent_addr);
186 log_develop_trace(gc, ref)("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj));
187 if (!oopDesc::is_null(heap_oop)) {
188 oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
189 if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
190 PSParallelCompact::ref_processor()->discover_reference(obj, klass->reference_type())) {
191 // reference already enqueued, referent will be traversed later
192 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
193 log_develop_trace(gc, ref)(" Non NULL enqueued " PTR_FORMAT, p2i(obj));
194 return;
195 } else {
196 // treat referent as normal oop
197 log_develop_trace(gc, ref)(" Non NULL normal " PTR_FORMAT, p2i(obj));
198 cm->mark_and_push(referent_addr);
199 }
200 }
201 T* next_addr = (T*)java_lang_ref_Reference::next_addr_raw(obj);
202 // Treat discovered as normal oop, if ref is not "active",
203 // i.e. if next is non-NULL.
204 T next_oop = oopDesc::load_heap_oop(next_addr);
205 if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active"
206 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr_raw(obj);
207 log_develop_trace(gc, ref)(" Process discovered as normal " PTR_FORMAT, p2i(discovered_addr));
208 cm->mark_and_push(discovered_addr);
209 }
210 cm->mark_and_push(next_addr);
211 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
212 }
213
214
215 void InstanceRefKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
216 if (UseCompressedOops) {
217 oop_pc_follow_contents_specialized<narrowOop>(this, obj, cm);
218 } else {
219 oop_pc_follow_contents_specialized<oop>(this, obj, cm);
220 }
221 }
222
223 void ObjArrayKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
224 cm->follow_klass(this);
225
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "gc/parallel/gcTaskManager.hpp"
28 #include "gc/parallel/objectStartArray.hpp"
29 #include "gc/parallel/parMarkBitMap.inline.hpp"
30 #include "gc/parallel/parallelScavengeHeap.hpp"
31 #include "gc/parallel/psCompactionManager.inline.hpp"
32 #include "gc/parallel/psOldGen.hpp"
33 #include "gc/parallel/psParallelCompact.inline.hpp"
34 #include "gc/shared/taskqueue.inline.hpp"
35 #include "logging/log.hpp"
36 #include "memory/iterator.inline.hpp"
37 #include "oops/access.inline.hpp"
38 #include "oops/compressedOops.inline.hpp"
39 #include "oops/instanceKlass.inline.hpp"
40 #include "oops/instanceMirrorKlass.inline.hpp"
41 #include "oops/objArrayKlass.inline.hpp"
42 #include "oops/oop.inline.hpp"
43 #include "runtime/atomic.hpp"
44
45 PSOldGen* ParCompactionManager::_old_gen = NULL;
46 ParCompactionManager** ParCompactionManager::_manager_array = NULL;
47
48 OopTaskQueueSet* ParCompactionManager::_stack_array = NULL;
49 ParCompactionManager::ObjArrayTaskQueueSet*
50 ParCompactionManager::_objarray_queues = NULL;
51 ObjectStartArray* ParCompactionManager::_start_array = NULL;
52 ParMarkBitMap* ParCompactionManager::_mark_bitmap = NULL;
53 RegionTaskQueueSet* ParCompactionManager::_region_array = NULL;
54
55 ParCompactionManager::ParCompactionManager() :
56 _action(CopyAndUpdate) {
57
58 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
167 // roots in Universe::oops_do.
168 assert(java_lang_Class::is_primitive(obj), "Sanity check");
169 }
170
171 ParCompactionManager::MarkAndPushClosure cl(cm);
172 oop_oop_iterate_statics<true>(obj, &cl);
173 }
174
175 void InstanceClassLoaderKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
176 InstanceKlass::oop_pc_follow_contents(obj, cm);
177
178 ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
179 if (loader_data != NULL) {
180 cm->follow_class_loader(loader_data);
181 }
182 }
183
184 template <class T>
185 static void oop_pc_follow_contents_specialized(InstanceRefKlass* klass, oop obj, ParCompactionManager* cm) {
186 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr_raw(obj);
187 T heap_oop = RawAccess<>::oop_load(referent_addr);
188 log_develop_trace(gc, ref)("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj));
189 if (!CompressedOops::is_null(heap_oop)) {
190 oop referent = CompressedOops::decode_not_null(heap_oop);
191 if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
192 PSParallelCompact::ref_processor()->discover_reference(obj, klass->reference_type())) {
193 // reference already enqueued, referent will be traversed later
194 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
195 log_develop_trace(gc, ref)(" Non NULL enqueued " PTR_FORMAT, p2i(obj));
196 return;
197 } else {
198 // treat referent as normal oop
199 log_develop_trace(gc, ref)(" Non NULL normal " PTR_FORMAT, p2i(obj));
200 cm->mark_and_push(referent_addr);
201 }
202 }
203 T* next_addr = (T*)java_lang_ref_Reference::next_addr_raw(obj);
204 // Treat discovered as normal oop, if ref is not "active",
205 // i.e. if next is non-NULL.
206 T next_oop = RawAccess<>::oop_load(next_addr);
207 if (!CompressedOops::is_null(next_oop)) { // i.e. ref is not "active"
208 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr_raw(obj);
209 log_develop_trace(gc, ref)(" Process discovered as normal " PTR_FORMAT, p2i(discovered_addr));
210 cm->mark_and_push(discovered_addr);
211 }
212 cm->mark_and_push(next_addr);
213 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
214 }
215
216
217 void InstanceRefKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
218 if (UseCompressedOops) {
219 oop_pc_follow_contents_specialized<narrowOop>(this, obj, cm);
220 } else {
221 oop_pc_follow_contents_specialized<oop>(this, obj, cm);
222 }
223 }
224
225 void ObjArrayKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
226 cm->follow_klass(this);
227
|