Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 6008:b632e80fc9dc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
4988100: oop_verify_old_oop appears to be dead Summary: removed oop_verify_old_oop and allow_dirty. Also reviewed by: alexlamsl@gmail.com Reviewed-by: jmasa, jwilhelm
author brutisso
date Mon, 16 Apr 2012 08:57:18 +0200
parents 5c86f8211d1e
children 720b6a76dd9d
comparison
equal deleted inserted replaced
6007:5c86f8211d1e 6008:b632e80fc9dc
1289 1289
1290 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) { 1290 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) {
1291 HandleMark hm; // Discard invalid handles created during verification 1291 HandleMark hm; // Discard invalid handles created during verification
1292 gclog_or_tty->print(" VerifyBeforeGC:"); 1292 gclog_or_tty->print(" VerifyBeforeGC:");
1293 prepare_for_verify(); 1293 prepare_for_verify();
1294 Universe::verify(/* allow dirty */ true, 1294 Universe::verify(/* silent */ false,
1295 /* silent */ false,
1296 /* option */ VerifyOption_G1UsePrevMarking); 1295 /* option */ VerifyOption_G1UsePrevMarking);
1297 1296
1298 } 1297 }
1299 pre_full_gc_dump(); 1298 pre_full_gc_dump();
1300 1299
1364 1363
1365 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) { 1364 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) {
1366 HandleMark hm; // Discard invalid handles created during verification 1365 HandleMark hm; // Discard invalid handles created during verification
1367 gclog_or_tty->print(" VerifyAfterGC:"); 1366 gclog_or_tty->print(" VerifyAfterGC:");
1368 prepare_for_verify(); 1367 prepare_for_verify();
1369 Universe::verify(/* allow dirty */ false, 1368 Universe::verify(/* silent */ false,
1370 /* silent */ false,
1371 /* option */ VerifyOption_G1UsePrevMarking); 1369 /* option */ VerifyOption_G1UsePrevMarking);
1372 1370
1373 } 1371 }
1374 1372
1375 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); 1373 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
3034 } 3032 }
3035 }; 3033 };
3036 3034
3037 class VerifyRegionClosure: public HeapRegionClosure { 3035 class VerifyRegionClosure: public HeapRegionClosure {
3038 private: 3036 private:
3039 bool _allow_dirty;
3040 bool _par; 3037 bool _par;
3041 VerifyOption _vo; 3038 VerifyOption _vo;
3042 bool _failures; 3039 bool _failures;
3043 public: 3040 public:
3044 // _vo == UsePrevMarking -> use "prev" marking information, 3041 // _vo == UsePrevMarking -> use "prev" marking information,
3045 // _vo == UseNextMarking -> use "next" marking information, 3042 // _vo == UseNextMarking -> use "next" marking information,
3046 // _vo == UseMarkWord -> use mark word from object header. 3043 // _vo == UseMarkWord -> use mark word from object header.
3047 VerifyRegionClosure(bool allow_dirty, bool par, VerifyOption vo) 3044 VerifyRegionClosure(bool par, VerifyOption vo)
3048 : _allow_dirty(allow_dirty), 3045 : _par(par),
3049 _par(par),
3050 _vo(vo), 3046 _vo(vo),
3051 _failures(false) {} 3047 _failures(false) {}
3052 3048
3053 bool failures() { 3049 bool failures() {
3054 return _failures; 3050 return _failures;
3057 bool doHeapRegion(HeapRegion* r) { 3053 bool doHeapRegion(HeapRegion* r) {
3058 guarantee(_par || r->claim_value() == HeapRegion::InitialClaimValue, 3054 guarantee(_par || r->claim_value() == HeapRegion::InitialClaimValue,
3059 "Should be unclaimed at verify points."); 3055 "Should be unclaimed at verify points.");
3060 if (!r->continuesHumongous()) { 3056 if (!r->continuesHumongous()) {
3061 bool failures = false; 3057 bool failures = false;
3062 r->verify(_allow_dirty, _vo, &failures); 3058 r->verify(_vo, &failures);
3063 if (failures) { 3059 if (failures) {
3064 _failures = true; 3060 _failures = true;
3065 } else { 3061 } else {
3066 VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo); 3062 VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo);
3067 r->object_iterate(&not_dead_yet_cl); 3063 r->object_iterate(&not_dead_yet_cl);
3125 // This is the task used for parallel heap verification. 3121 // This is the task used for parallel heap verification.
3126 3122
3127 class G1ParVerifyTask: public AbstractGangTask { 3123 class G1ParVerifyTask: public AbstractGangTask {
3128 private: 3124 private:
3129 G1CollectedHeap* _g1h; 3125 G1CollectedHeap* _g1h;
3130 bool _allow_dirty;
3131 VerifyOption _vo; 3126 VerifyOption _vo;
3132 bool _failures; 3127 bool _failures;
3133 3128
3134 public: 3129 public:
3135 // _vo == UsePrevMarking -> use "prev" marking information, 3130 // _vo == UsePrevMarking -> use "prev" marking information,
3136 // _vo == UseNextMarking -> use "next" marking information, 3131 // _vo == UseNextMarking -> use "next" marking information,
3137 // _vo == UseMarkWord -> use mark word from object header. 3132 // _vo == UseMarkWord -> use mark word from object header.
3138 G1ParVerifyTask(G1CollectedHeap* g1h, bool allow_dirty, VerifyOption vo) : 3133 G1ParVerifyTask(G1CollectedHeap* g1h, VerifyOption vo) :
3139 AbstractGangTask("Parallel verify task"), 3134 AbstractGangTask("Parallel verify task"),
3140 _g1h(g1h), 3135 _g1h(g1h),
3141 _allow_dirty(allow_dirty),
3142 _vo(vo), 3136 _vo(vo),
3143 _failures(false) { } 3137 _failures(false) { }
3144 3138
3145 bool failures() { 3139 bool failures() {
3146 return _failures; 3140 return _failures;
3147 } 3141 }
3148 3142
3149 void work(uint worker_id) { 3143 void work(uint worker_id) {
3150 HandleMark hm; 3144 HandleMark hm;
3151 VerifyRegionClosure blk(_allow_dirty, true, _vo); 3145 VerifyRegionClosure blk(true, _vo);
3152 _g1h->heap_region_par_iterate_chunked(&blk, worker_id, 3146 _g1h->heap_region_par_iterate_chunked(&blk, worker_id,
3153 _g1h->workers()->active_workers(), 3147 _g1h->workers()->active_workers(),
3154 HeapRegion::ParVerifyClaimValue); 3148 HeapRegion::ParVerifyClaimValue);
3155 if (blk.failures()) { 3149 if (blk.failures()) {
3156 _failures = true; 3150 _failures = true;
3157 } 3151 }
3158 } 3152 }
3159 }; 3153 };
3160 3154
3161 void G1CollectedHeap::verify(bool allow_dirty, bool silent) { 3155 void G1CollectedHeap::verify(bool silent) {
3162 verify(allow_dirty, silent, VerifyOption_G1UsePrevMarking); 3156 verify(silent, VerifyOption_G1UsePrevMarking);
3163 } 3157 }
3164 3158
3165 void G1CollectedHeap::verify(bool allow_dirty, 3159 void G1CollectedHeap::verify(bool silent,
3166 bool silent,
3167 VerifyOption vo) { 3160 VerifyOption vo) {
3168 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { 3161 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) {
3169 if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); } 3162 if (!silent) { gclog_or_tty->print("Roots (excluding permgen) "); }
3170 VerifyRootsClosure rootsCl(vo); 3163 VerifyRootsClosure rootsCl(vo);
3171 3164
3213 if (!silent) { gclog_or_tty->print("HeapRegions "); } 3206 if (!silent) { gclog_or_tty->print("HeapRegions "); }
3214 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { 3207 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) {
3215 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), 3208 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
3216 "sanity check"); 3209 "sanity check");
3217 3210
3218 G1ParVerifyTask task(this, allow_dirty, vo); 3211 G1ParVerifyTask task(this, vo);
3219 assert(UseDynamicNumberOfGCThreads || 3212 assert(UseDynamicNumberOfGCThreads ||
3220 workers()->active_workers() == workers()->total_workers(), 3213 workers()->active_workers() == workers()->total_workers(),
3221 "If not dynamic should be using all the workers"); 3214 "If not dynamic should be using all the workers");
3222 int n_workers = workers()->active_workers(); 3215 int n_workers = workers()->active_workers();
3223 set_par_threads(n_workers); 3216 set_par_threads(n_workers);
3235 reset_heap_region_claim_values(); 3228 reset_heap_region_claim_values();
3236 3229
3237 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), 3230 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue),
3238 "sanity check"); 3231 "sanity check");
3239 } else { 3232 } else {
3240 VerifyRegionClosure blk(allow_dirty, false, vo); 3233 VerifyRegionClosure blk(false, vo);
3241 heap_region_iterate(&blk); 3234 heap_region_iterate(&blk);
3242 if (blk.failures()) { 3235 if (blk.failures()) {
3243 failures = true; 3236 failures = true;
3244 } 3237 }
3245 } 3238 }
3648 3641
3649 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) { 3642 if (VerifyBeforeGC && total_collections() >= VerifyGCStartAt) {
3650 HandleMark hm; // Discard invalid handles created during verification 3643 HandleMark hm; // Discard invalid handles created during verification
3651 gclog_or_tty->print(" VerifyBeforeGC:"); 3644 gclog_or_tty->print(" VerifyBeforeGC:");
3652 prepare_for_verify(); 3645 prepare_for_verify();
3653 Universe::verify(/* allow dirty */ false, 3646 Universe::verify(/* silent */ false,
3654 /* silent */ false,
3655 /* option */ VerifyOption_G1UsePrevMarking); 3647 /* option */ VerifyOption_G1UsePrevMarking);
3656 } 3648 }
3657 3649
3658 COMPILER2_PRESENT(DerivedPointerTable::clear()); 3650 COMPILER2_PRESENT(DerivedPointerTable::clear());
3659 3651
3893 3885
3894 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) { 3886 if (VerifyAfterGC && total_collections() >= VerifyGCStartAt) {
3895 HandleMark hm; // Discard invalid handles created during verification 3887 HandleMark hm; // Discard invalid handles created during verification
3896 gclog_or_tty->print(" VerifyAfterGC:"); 3888 gclog_or_tty->print(" VerifyAfterGC:");
3897 prepare_for_verify(); 3889 prepare_for_verify();
3898 Universe::verify(/* allow dirty */ true, 3890 Universe::verify(/* silent */ false,
3899 /* silent */ false,
3900 /* option */ VerifyOption_G1UsePrevMarking); 3891 /* option */ VerifyOption_G1UsePrevMarking);
3901 } 3892 }
3902 3893
3903 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); 3894 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
3904 ref_processor_stw()->verify_no_references_recorded(); 3895 ref_processor_stw()->verify_no_references_recorded();