779 */
780 return NULL;
781 }
782 }
783
784 class ParallelEvacuateRegionObjectClosure : public ObjectClosure {
785 private:
786 ShenandoahHeap* _heap;
787 Thread* _thread;
788 public:
789 ParallelEvacuateRegionObjectClosure(ShenandoahHeap* heap) :
790 _heap(heap), _thread(Thread::current()) {
791 }
792
793 void do_object(oop p) {
794
795 log_develop_trace(gc, compaction)("Calling ParallelEvacuateRegionObjectClosure on "PTR_FORMAT" of size %d\n", p2i((HeapWord*) p), p->size());
796
797 assert(_heap->is_marked_complete(p), "expect only marked objects");
798 if (oopDesc::unsafe_equals(p, ShenandoahBarrierSet::resolve_oop_static_not_null(p))) {
799 _heap->evacuate_object(p, _thread);
800 }
801 }
802 };
803
804 #ifdef ASSERT
805 class VerifyEvacuatedObjectClosure : public ObjectClosure {
806
807 public:
808
809 void do_object(oop p) {
810 if (ShenandoahHeap::heap()->is_marked_complete(p)) {
811 oop p_prime = oopDesc::bs()->read_barrier(p);
812 assert(! oopDesc::unsafe_equals(p, p_prime), "Should point to evacuated copy");
813 if (p->klass() != p_prime->klass()) {
814 tty->print_cr("copy has different class than original:");
815 p->klass()->print_on(tty);
816 p_prime->klass()->print_on(tty);
817 }
818 assert(p->klass() == p_prime->klass(), "Should have the same class p: "PTR_FORMAT", p_prime: "PTR_FORMAT, p2i(p), p2i(p_prime));
819 // assert(p->mark() == p_prime->mark(), "Should have the same mark");
1213 ShenandoahHeap* _heap;
1214 Thread* _thread;
1215 public:
1216 ShenandoahEvacuateUpdateRootsClosure() :
1217 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
1218 }
1219
1220 private:
1221 template <class T>
1222 void do_oop_work(T* p) {
1223 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
1224
1225 T o = oopDesc::load_heap_oop(p);
1226 if (! oopDesc::is_null(o)) {
1227 oop obj = oopDesc::decode_heap_oop_not_null(o);
1228 if (_heap->in_collection_set(obj)) {
1229 assert(_heap->is_marked_complete(obj), "only evacuate marked objects %d %d",
1230 _heap->is_marked_complete(obj), _heap->is_marked_complete(ShenandoahBarrierSet::resolve_oop_static_not_null(obj)));
1231 oop resolved = ShenandoahBarrierSet::resolve_oop_static_not_null(obj);
1232 if (oopDesc::unsafe_equals(resolved, obj)) {
1233 resolved = _heap->evacuate_object(obj, _thread);
1234 }
1235 oopDesc::encode_store_heap_oop(p, resolved);
1236 }
1237 }
1238 #ifdef ASSERT
1239 else {
1240 // tty->print_cr("not updating root at: "PTR_FORMAT" with object: "PTR_FORMAT", is_in_heap: %s, is_in_cset: %s, is_marked: %s",
1241 // p2i(p),
1242 // p2i((HeapWord*) obj),
1243 // BOOL_TO_STR(_heap->is_in(obj)),
1244 // BOOL_TO_STR(_heap->in_cset_fast_test(obj)),
1245 // BOOL_TO_STR(_heap->is_marked_complete(obj)));
1246 }
1247 #endif
1248 }
1249
1250 public:
1251 void do_oop(oop* p) {
1252 do_oop_work(p);
1253 }
|
779 */
780 return NULL;
781 }
782 }
783
784 class ParallelEvacuateRegionObjectClosure : public ObjectClosure {
785 private:
786 ShenandoahHeap* _heap;
787 Thread* _thread;
788 public:
789 ParallelEvacuateRegionObjectClosure(ShenandoahHeap* heap) :
790 _heap(heap), _thread(Thread::current()) {
791 }
792
793 void do_object(oop p) {
794
795 log_develop_trace(gc, compaction)("Calling ParallelEvacuateRegionObjectClosure on "PTR_FORMAT" of size %d\n", p2i((HeapWord*) p), p->size());
796
797 assert(_heap->is_marked_complete(p), "expect only marked objects");
798 if (oopDesc::unsafe_equals(p, ShenandoahBarrierSet::resolve_oop_static_not_null(p))) {
799 bool evac;
800 _heap->evacuate_object(p, _thread, evac);
801 }
802 }
803 };
804
805 #ifdef ASSERT
806 class VerifyEvacuatedObjectClosure : public ObjectClosure {
807
808 public:
809
810 void do_object(oop p) {
811 if (ShenandoahHeap::heap()->is_marked_complete(p)) {
812 oop p_prime = oopDesc::bs()->read_barrier(p);
813 assert(! oopDesc::unsafe_equals(p, p_prime), "Should point to evacuated copy");
814 if (p->klass() != p_prime->klass()) {
815 tty->print_cr("copy has different class than original:");
816 p->klass()->print_on(tty);
817 p_prime->klass()->print_on(tty);
818 }
819 assert(p->klass() == p_prime->klass(), "Should have the same class p: "PTR_FORMAT", p_prime: "PTR_FORMAT, p2i(p), p2i(p_prime));
820 // assert(p->mark() == p_prime->mark(), "Should have the same mark");
1214 ShenandoahHeap* _heap;
1215 Thread* _thread;
1216 public:
1217 ShenandoahEvacuateUpdateRootsClosure() :
1218 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
1219 }
1220
1221 private:
1222 template <class T>
1223 void do_oop_work(T* p) {
1224 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
1225
1226 T o = oopDesc::load_heap_oop(p);
1227 if (! oopDesc::is_null(o)) {
1228 oop obj = oopDesc::decode_heap_oop_not_null(o);
1229 if (_heap->in_collection_set(obj)) {
1230 assert(_heap->is_marked_complete(obj), "only evacuate marked objects %d %d",
1231 _heap->is_marked_complete(obj), _heap->is_marked_complete(ShenandoahBarrierSet::resolve_oop_static_not_null(obj)));
1232 oop resolved = ShenandoahBarrierSet::resolve_oop_static_not_null(obj);
1233 if (oopDesc::unsafe_equals(resolved, obj)) {
1234 bool evac;
1235 resolved = _heap->evacuate_object(obj, _thread, evac);
1236 }
1237 oopDesc::encode_store_heap_oop(p, resolved);
1238 }
1239 }
1240 #ifdef ASSERT
1241 else {
1242 // tty->print_cr("not updating root at: "PTR_FORMAT" with object: "PTR_FORMAT", is_in_heap: %s, is_in_cset: %s, is_marked: %s",
1243 // p2i(p),
1244 // p2i((HeapWord*) obj),
1245 // BOOL_TO_STR(_heap->is_in(obj)),
1246 // BOOL_TO_STR(_heap->in_cset_fast_test(obj)),
1247 // BOOL_TO_STR(_heap->is_marked_complete(obj)));
1248 }
1249 #endif
1250 }
1251
1252 public:
1253 void do_oop(oop* p) {
1254 do_oop_work(p);
1255 }
|