< prev index next >

src/share/vm/gc/parallel/psParallelCompact.cpp

Print this page




3088   }
3089   update_state(words);
3090 }
3091 
3092 void InstanceKlass::oop_pc_update_pointers(oop obj) {
3093   oop_oop_iterate_oop_maps<true>(obj, PSParallelCompact::adjust_pointer_closure());
3094 }
3095 
3096 void InstanceMirrorKlass::oop_pc_update_pointers(oop obj) {
3097   InstanceKlass::oop_pc_update_pointers(obj);
3098 
3099   oop_oop_iterate_statics<true>(obj, PSParallelCompact::adjust_pointer_closure());
3100 }
3101 
3102 void InstanceClassLoaderKlass::oop_pc_update_pointers(oop obj) {
3103   InstanceKlass::oop_pc_update_pointers(obj);
3104 }
3105 
3106 #ifdef ASSERT
3107 template <class T> static void trace_reference_gc(const char *s, oop obj,

3108                                                   T* referent_addr,
3109                                                   T* next_addr,
3110                                                   T* discovered_addr) {

3111   if(TraceReferenceGC && PrintGCDetails) {
3112     gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));
3113     gclog_or_tty->print_cr("     referent_addr/* " PTR_FORMAT " / "
3114                            PTR_FORMAT, p2i(referent_addr),
3115                            referent_addr ? p2i(oopDesc::load_decode_heap_oop(referent_addr)) : NULL);
3116     gclog_or_tty->print_cr("     next_addr/* " PTR_FORMAT " / "
3117                            PTR_FORMAT, p2i(next_addr),
3118                            next_addr ? p2i(oopDesc::load_decode_heap_oop(next_addr)) : NULL);
3119     gclog_or_tty->print_cr("     discovered_addr/* " PTR_FORMAT " / "
3120                            PTR_FORMAT, p2i(discovered_addr),
3121                            discovered_addr ? p2i(oopDesc::load_decode_heap_oop(discovered_addr)) : NULL);





3122   }
3123 }
3124 #endif
3125 
3126 template <class T>
3127 static void oop_pc_update_pointers_specialized(oop obj) {
3128   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
3129   PSParallelCompact::adjust_pointer(referent_addr);
3130   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
3131   PSParallelCompact::adjust_pointer(next_addr);
3132   T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
3133   PSParallelCompact::adjust_pointer(discovered_addr);
3134   debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
3135                                 referent_addr, next_addr, discovered_addr);)







3136 }
3137 
3138 void InstanceRefKlass::oop_pc_update_pointers(oop obj) {
3139   InstanceKlass::oop_pc_update_pointers(obj);
3140 
3141   if (UseCompressedOops) {
3142     oop_pc_update_pointers_specialized<narrowOop>(obj);
3143   } else {
3144     oop_pc_update_pointers_specialized<oop>(obj);
3145   }
3146 }
3147 
3148 void ObjArrayKlass::oop_pc_update_pointers(oop obj) {
3149   assert(obj->is_objArray(), "obj must be obj array");
3150   oop_oop_iterate_elements<true>(objArrayOop(obj), PSParallelCompact::adjust_pointer_closure());
3151 }
3152 
3153 void TypeArrayKlass::oop_pc_update_pointers(oop obj) {
3154   assert(obj->is_typeArray(),"must be a type array");
3155 }
3156 
3157 ParMarkBitMapClosure::IterationStatus
3158 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
3159   assert(destination() != NULL, "sanity");
3160   assert(bitmap()->obj_size(addr) == words, "bad size");
3161 
3162   _source = addr;
3163   assert(PSParallelCompact::summary_data().calc_new_pointer(source()) ==
3164          destination(), "wrong destination");




3088   }
3089   update_state(words);
3090 }
3091 
3092 void InstanceKlass::oop_pc_update_pointers(oop obj) {
3093   oop_oop_iterate_oop_maps<true>(obj, PSParallelCompact::adjust_pointer_closure());
3094 }
3095 
3096 void InstanceMirrorKlass::oop_pc_update_pointers(oop obj) {
3097   InstanceKlass::oop_pc_update_pointers(obj);
3098 
3099   oop_oop_iterate_statics<true>(obj, PSParallelCompact::adjust_pointer_closure());
3100 }
3101 
3102 void InstanceClassLoaderKlass::oop_pc_update_pointers(oop obj) {
3103   InstanceKlass::oop_pc_update_pointers(obj);
3104 }
3105 
3106 #ifdef ASSERT
3107 template <class T> static void trace_reference_gc(const char *s, oop obj,
3108                                                   bool is_ephemeron,
3109                                                   T* referent_addr,
3110                                                   T* next_addr,
3111                                                   T* discovered_addr,
3112                                                   T* value_addr) {
3113   if(TraceReferenceGC && PrintGCDetails) {
3114     gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));
3115     gclog_or_tty->print_cr("     referent_addr/* " PTR_FORMAT " / "
3116                            PTR_FORMAT, p2i(referent_addr),
3117                            referent_addr ? p2i(oopDesc::load_decode_heap_oop(referent_addr)) : NULL);
3118     gclog_or_tty->print_cr("     next_addr/* " PTR_FORMAT " / "
3119                            PTR_FORMAT, p2i(next_addr),
3120                            next_addr ? p2i(oopDesc::load_decode_heap_oop(next_addr)) : NULL);
3121     gclog_or_tty->print_cr("     discovered_addr/* " PTR_FORMAT " / "
3122                            PTR_FORMAT, p2i(discovered_addr),
3123                            discovered_addr ? p2i(oopDesc::load_decode_heap_oop(discovered_addr)) : NULL);
3124     if (is_ephemeron) {
3125       gclog_or_tty->print_cr("     value_addr/* " PTR_FORMAT " / "
3126                              PTR_FORMAT, p2i(value_addr),
3127                              value_addr ? p2i(oopDesc::load_decode_heap_oop(value_addr)) : NULL);
3128     }
3129   }
3130 }
3131 #endif
3132 
3133 template <class T>
3134 static void oop_pc_update_pointers_specialized(oop obj, InstanceRefKlass* klass) {
3135   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
3136   PSParallelCompact::adjust_pointer(referent_addr);
3137   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
3138   PSParallelCompact::adjust_pointer(next_addr);
3139   T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
3140   PSParallelCompact::adjust_pointer(discovered_addr);
3141   if (klass->reference_type() == REF_EPHEMERON) {
3142     T* value_addr = (T*)java_lang_ref_Ephemeron::value_addr(obj);
3143     PSParallelCompact::adjust_pointer(value_addr);
3144     debug_only(trace_reference_gc("InstanceRefKlass<Ephemeron>::oop_update_ptrs", obj, true,
3145                                   referent_addr, next_addr, discovered_addr, value_addr);)
3146   } else {
3147     debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj, false,
3148                                   referent_addr, next_addr, discovered_addr, (T*)NULL);)
3149   }
3150 }
3151 
3152 void InstanceRefKlass::oop_pc_update_pointers(oop obj) {
3153   InstanceKlass::oop_pc_update_pointers(obj);
3154 
3155   if (UseCompressedOops) {
3156     oop_pc_update_pointers_specialized<narrowOop>(obj, this);
3157   } else {
3158     oop_pc_update_pointers_specialized<oop>(obj, this);
3159   }
3160 }
3161 
3162 void ObjArrayKlass::oop_pc_update_pointers(oop obj) {
3163   assert(obj->is_objArray(), "obj must be obj array");
3164   oop_oop_iterate_elements<true>(objArrayOop(obj), PSParallelCompact::adjust_pointer_closure());
3165 }
3166 
3167 void TypeArrayKlass::oop_pc_update_pointers(oop obj) {
3168   assert(obj->is_typeArray(),"must be a type array");
3169 }
3170 
3171 ParMarkBitMapClosure::IterationStatus
3172 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
3173   assert(destination() != NULL, "sanity");
3174   assert(bitmap()->obj_size(addr) == words, "bad size");
3175 
3176   _source = addr;
3177   assert(PSParallelCompact::summary_data().calc_new_pointer(source()) ==
3178          destination(), "wrong destination");


< prev index next >