355 // Read it again in case it changed while we were waiting for the lock. 356 res = _next_survivor; 357 if (res != NULL) { 358 if (res == _young_list->last_survivor_region()) { 359 // We just claimed the last survivor so store NULL to indicate 360 // that we're done. 361 _next_survivor = NULL; 362 } else { 363 _next_survivor = res->get_next_young_region(); 364 } 365 } else { 366 // Someone else claimed the last survivor while we were trying 367 // to take the lock so nothing else to do. 368 } 369 } 370 assert(res == NULL || res->is_survivor(), "post-condition"); 371 372 return res; 373 } 374 375 void G1CMRootRegions::scan_finished() { 376 assert(scan_in_progress(), "pre-condition"); 377 378 // Currently, only survivors can be root regions. 379 if (!_should_abort) { 380 assert(_next_survivor == NULL, "we should have claimed all survivors"); 381 } 382 _next_survivor = NULL; 383 384 { 385 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag); 386 _scan_in_progress = false; 387 RootRegionScan_lock->notify_all(); 388 } 389 } 390 391 bool G1CMRootRegions::wait_until_scan_finished() { 392 if (!scan_in_progress()) return false; 393 394 { 395 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag); 396 while (scan_in_progress()) { 397 RootRegionScan_lock->wait(Mutex::_no_safepoint_check_flag); 398 } 399 } 400 return true; 401 } 402 403 uint G1ConcurrentMark::scale_parallel_threads(uint n_par_threads) { 404 return MAX2((n_par_threads + 2) / 4, 1U); 405 } 406 407 G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h, G1RegionToSpaceMapper* prev_bitmap_storage, G1RegionToSpaceMapper* next_bitmap_storage) : 408 _g1h(g1h), | 355 // Read it again in case it changed while we were waiting for the lock. 356 res = _next_survivor; 357 if (res != NULL) { 358 if (res == _young_list->last_survivor_region()) { 359 // We just claimed the last survivor so store NULL to indicate 360 // that we're done. 361 _next_survivor = NULL; 362 } else { 363 _next_survivor = res->get_next_young_region(); 364 } 365 } else { 366 // Someone else claimed the last survivor while we were trying 367 // to take the lock so nothing else to do. 368 } 369 } 370 assert(res == NULL || res->is_survivor(), "post-condition"); 371 372 return res; 373 } 374 375 void G1CMRootRegions::notify_scan_done() { 376 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag); 377 _scan_in_progress = false; 378 RootRegionScan_lock->notify_all(); 379 } 380 381 void G1CMRootRegions::cancel_scan() { 382 notify_scan_done(); 383 } 384 385 void G1CMRootRegions::scan_finished() { 386 assert(scan_in_progress(), "pre-condition"); 387 388 // Currently, only survivors can be root regions. 389 if (!_should_abort) { 390 assert(_next_survivor == NULL, "we should have claimed all survivors"); 391 } 392 _next_survivor = NULL; 393 394 notify_scan_done(); 395 } 396 397 bool G1CMRootRegions::wait_until_scan_finished() { 398 if (!scan_in_progress()) return false; 399 400 { 401 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag); 402 while (scan_in_progress()) { 403 RootRegionScan_lock->wait(Mutex::_no_safepoint_check_flag); 404 } 405 } 406 return true; 407 } 408 409 uint G1ConcurrentMark::scale_parallel_threads(uint n_par_threads) { 410 return MAX2((n_par_threads + 2) / 4, 1U); 411 } 412 413 G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h, G1RegionToSpaceMapper* prev_bitmap_storage, G1RegionToSpaceMapper* next_bitmap_storage) : 414 _g1h(g1h), |