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 *
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.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 "memory/iterator.inline.hpp"
36 #include "oops/instanceKlass.inline.hpp"
37 #include "oops/instanceMirrorKlass.inline.hpp"
38 #include "oops/objArrayKlass.inline.hpp"
39 #include "oops/oop.inline.hpp"
40 #include "runtime/atomic.inline.hpp"
41
42 PSOldGen* ParCompactionManager::_old_gen = NULL;
43 ParCompactionManager** ParCompactionManager::_manager_array = NULL;
44
45 RegionTaskQueue** ParCompactionManager::_region_list = NULL;
46
47 OopTaskQueueSet* ParCompactionManager::_stack_array = NULL;
48 ParCompactionManager::ObjArrayTaskQueueSet*
49 ParCompactionManager::_objarray_queues = NULL;
50 ObjectStartArray* ParCompactionManager::_start_array = NULL;
51 ParMarkBitMap* ParCompactionManager::_mark_bitmap = NULL;
52 RegionTaskQueueSet* ParCompactionManager::_region_array = NULL;
53
54 uint* ParCompactionManager::_recycled_stack_index = NULL;
212 assert(java_lang_Class::is_primitive(obj), "Sanity check");
213 }
214
215 ParCompactionManager::MarkAndPushClosure cl(cm);
216 oop_oop_iterate_statics<true>(obj, &cl);
217 }
218
219 void InstanceClassLoaderKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
220 InstanceKlass::oop_pc_follow_contents(obj, cm);
221
222 ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
223 if (loader_data != NULL) {
224 cm->follow_class_loader(loader_data);
225 }
226 }
227
228 template <class T>
229 static void oop_pc_follow_contents_specialized(InstanceRefKlass* klass, oop obj, ParCompactionManager* cm) {
230 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
231 T heap_oop = oopDesc::load_heap_oop(referent_addr);
232 debug_only(
233 if(TraceReferenceGC && PrintGCDetails) {
234 gclog_or_tty->print_cr("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj));
235 }
236 )
237 if (!oopDesc::is_null(heap_oop)) {
238 oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
239 if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
240 PSParallelCompact::ref_processor()->discover_reference(obj, klass->reference_type())) {
241 // reference already enqueued, referent will be traversed later
242 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
243 debug_only(
244 if(TraceReferenceGC && PrintGCDetails) {
245 gclog_or_tty->print_cr(" Non NULL enqueued " PTR_FORMAT, p2i(obj));
246 }
247 )
248 return;
249 } else {
250 // treat referent as normal oop
251 debug_only(
252 if(TraceReferenceGC && PrintGCDetails) {
253 gclog_or_tty->print_cr(" Non NULL normal " PTR_FORMAT, p2i(obj));
254 }
255 )
256 cm->mark_and_push(referent_addr);
257 }
258 }
259 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
260 // Treat discovered as normal oop, if ref is not "active",
261 // i.e. if next is non-NULL.
262 T next_oop = oopDesc::load_heap_oop(next_addr);
263 if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active"
264 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
265 debug_only(
266 if(TraceReferenceGC && PrintGCDetails) {
267 gclog_or_tty->print_cr(" Process discovered as normal "
268 PTR_FORMAT, p2i(discovered_addr));
269 }
270 )
271 cm->mark_and_push(discovered_addr);
272 }
273 cm->mark_and_push(next_addr);
274 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
275 }
276
277
278 void InstanceRefKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
279 if (UseCompressedOops) {
280 oop_pc_follow_contents_specialized<narrowOop>(this, obj, cm);
281 } else {
282 oop_pc_follow_contents_specialized<oop>(this, obj, cm);
283 }
284 }
285
286 void ObjArrayKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
287 cm->follow_klass(this);
288
289 if (UseCompressedOops) {
290 oop_pc_follow_contents_specialized<narrowOop>(objArrayOop(obj), 0, cm);
|
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 *
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.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.inline.hpp"
42
43 PSOldGen* ParCompactionManager::_old_gen = NULL;
44 ParCompactionManager** ParCompactionManager::_manager_array = NULL;
45
46 RegionTaskQueue** ParCompactionManager::_region_list = 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 uint* ParCompactionManager::_recycled_stack_index = NULL;
213 assert(java_lang_Class::is_primitive(obj), "Sanity check");
214 }
215
216 ParCompactionManager::MarkAndPushClosure cl(cm);
217 oop_oop_iterate_statics<true>(obj, &cl);
218 }
219
220 void InstanceClassLoaderKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
221 InstanceKlass::oop_pc_follow_contents(obj, cm);
222
223 ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
224 if (loader_data != NULL) {
225 cm->follow_class_loader(loader_data);
226 }
227 }
228
229 template <class T>
230 static void oop_pc_follow_contents_specialized(InstanceRefKlass* klass, oop obj, ParCompactionManager* cm) {
231 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
232 T heap_oop = oopDesc::load_heap_oop(referent_addr);
233 log_develop_trace(gc, ref)("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj));
234 if (!oopDesc::is_null(heap_oop)) {
235 oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
236 if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
237 PSParallelCompact::ref_processor()->discover_reference(obj, klass->reference_type())) {
238 // reference already enqueued, referent will be traversed later
239 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
240 log_develop_trace(gc, ref)(" Non NULL enqueued " PTR_FORMAT, p2i(obj));
241 return;
242 } else {
243 // treat referent as normal oop
244 log_develop_trace(gc, ref)(" Non NULL normal " PTR_FORMAT, p2i(obj));
245 cm->mark_and_push(referent_addr);
246 }
247 }
248 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
249 // Treat discovered as normal oop, if ref is not "active",
250 // i.e. if next is non-NULL.
251 T next_oop = oopDesc::load_heap_oop(next_addr);
252 if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active"
253 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
254 log_develop_trace(gc, ref)(" Process discovered as normal " PTR_FORMAT, p2i(discovered_addr));
255 cm->mark_and_push(discovered_addr);
256 }
257 cm->mark_and_push(next_addr);
258 klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
259 }
260
261
262 void InstanceRefKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
263 if (UseCompressedOops) {
264 oop_pc_follow_contents_specialized<narrowOop>(this, obj, cm);
265 } else {
266 oop_pc_follow_contents_specialized<oop>(this, obj, cm);
267 }
268 }
269
270 void ObjArrayKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
271 cm->follow_klass(this);
272
273 if (UseCompressedOops) {
274 oop_pc_follow_contents_specialized<narrowOop>(objArrayOop(obj), 0, cm);
|