< prev index next >
src/hotspot/share/gc/g1/g1CollectedHeap.cpp
8201171: Cleanup in g1CollectedHeap, change CamelCase to snake_case
Reviewed-by:
_cm = new G1ConcurrentMark(this, prev_bitmap_storage, next_bitmap_storage);
if (_cm == NULL || !_cm->completed_initialization()) {
vm_shutdown_during_initialization("Could not create/initialize G1ConcurrentMark");
return JNI_ENOMEM;
}
! _cmThread = _cm->cm_thread();
// Now expand into the initial heap size.
if (!expand(init_byte_size, _workers)) {
vm_shutdown_during_initialization("Failed to allocate initial heap.");
return JNI_ENOMEM;
_cm = new G1ConcurrentMark(this, prev_bitmap_storage, next_bitmap_storage);
if (_cm == NULL || !_cm->completed_initialization()) {
vm_shutdown_during_initialization("Could not create/initialize G1ConcurrentMark");
return JNI_ENOMEM;
}
! _cm_thread = _cm->cm_thread();
// Now expand into the initial heap size.
if (!expand(init_byte_size, _workers)) {
vm_shutdown_during_initialization("Failed to allocate initial heap.");
return JNI_ENOMEM;
***************
// Stop all concurrent threads. We do this to make sure these threads
// do not continue to execute and access resources (e.g. logging)
// that are destroyed during shutdown.
_cr->stop();
_young_gen_sampling_thread->stop();
! _cmThread->stop();
if (G1StringDedup::is_enabled()) {
G1StringDedup::stop();
}
}
// Stop all concurrent threads. We do this to make sure these threads
// do not continue to execute and access resources (e.g. logging)
// that are destroyed during shutdown.
_cr->stop();
_young_gen_sampling_thread->stop();
! _cm_thread->stop();
if (G1StringDedup::is_enabled()) {
G1StringDedup::stop();
}
}
***************
// We need to clear the "in_progress" flag in the CM thread before
// we wake up any waiters (especially when ExplicitInvokesConcurrent
// is set) so that if a waiter requests another System.gc() it doesn't
// incorrectly see that a marking cycle is still in progress.
if (concurrent) {
! _cmThread->set_idle();
}
// This notify_all() will ensure that a thread that called
// System.gc() with (with ExplicitGCInvokesConcurrent set or not)
// and it's waiting for a full GC to finish will be woken up. It is
// We need to clear the "in_progress" flag in the CM thread before
// we wake up any waiters (especially when ExplicitInvokesConcurrent
// is set) so that if a waiter requests another System.gc() it doesn't
// incorrectly see that a marking cycle is still in progress.
if (concurrent) {
! _cm_thread->set_idle();
}
// This notify_all() will ensure that a thread that called
// System.gc() with (with ExplicitGCInvokesConcurrent set or not)
// and it's waiting for a full GC to finish will be woken up. It is
***************
bool G1CollectedHeap::supports_concurrent_phase_control() const {
return true;
}
const char* const* G1CollectedHeap::concurrent_phases() const {
! return _cmThread->concurrent_phases();
}
bool G1CollectedHeap::request_concurrent_phase(const char* phase) {
! return _cmThread->request_concurrent_phase(phase);
}
class PrintRegionClosure: public HeapRegionClosure {
outputStream* _st;
public:
bool G1CollectedHeap::supports_concurrent_phase_control() const {
return true;
}
const char* const* G1CollectedHeap::concurrent_phases() const {
! return _cm_thread->concurrent_phases();
}
bool G1CollectedHeap::request_concurrent_phase(const char* phase) {
! return _cm_thread->request_concurrent_phase(phase);
}
class PrintRegionClosure: public HeapRegionClosure {
outputStream* _st;
public:
***************
}
}
void G1CollectedHeap::print_gc_threads_on(outputStream* st) const {
workers()->print_worker_threads_on(st);
! _cmThread->print_on(st);
st->cr();
_cm->print_worker_threads_on(st);
_cr->print_threads_on(st);
_young_gen_sampling_thread->print_on(st);
if (G1StringDedup::is_enabled()) {
}
}
void G1CollectedHeap::print_gc_threads_on(outputStream* st) const {
workers()->print_worker_threads_on(st);
! _cm_thread->print_on(st);
st->cr();
_cm->print_worker_threads_on(st);
_cr->print_threads_on(st);
_young_gen_sampling_thread->print_on(st);
if (G1StringDedup::is_enabled()) {
***************
}
}
void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const {
workers()->threads_do(tc);
! tc->do_thread(_cmThread);
_cm->threads_do(tc);
_cr->threads_do(tc);
tc->do_thread(_young_gen_sampling_thread);
if (G1StringDedup::is_enabled()) {
G1StringDedup::threads_do(tc);
}
}
void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const {
workers()->threads_do(tc);
! tc->do_thread(_cm_thread);
_cm->threads_do(tc);
_cr->threads_do(tc);
tc->do_thread(_young_gen_sampling_thread);
if (G1StringDedup::is_enabled()) {
G1StringDedup::threads_do(tc);
***************
return result;
}
void G1CollectedHeap::do_concurrent_mark() {
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
! if (!_cmThread->in_progress()) {
! _cmThread->set_started();
CGC_lock->notify();
}
}
size_t G1CollectedHeap::pending_card_num() {
return result;
}
void G1CollectedHeap::do_concurrent_mark() {
MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
! if (!_cm_thread->in_progress()) {
! _cm_thread->set_started();
CGC_lock->notify();
}
}
size_t G1CollectedHeap::pending_card_num() {
***************
_verifier->verify_region_sets_optional();
_verifier->verify_dirty_young_regions();
// We should not be doing initial mark unless the conc mark thread is running
! if (!_cmThread->should_terminate()) {
// This call will decide whether this pause is an initial-mark
// pause. If it is, in_initial_mark_gc() will return true
// for the duration of this pause.
g1_policy()->decide_on_conc_mark_initiation();
}
_verifier->verify_region_sets_optional();
_verifier->verify_dirty_young_regions();
// We should not be doing initial mark unless the conc mark thread is running
! if (!_cm_thread->should_terminate()) {
// This call will decide whether this pause is an initial-mark
// pause. If it is, in_initial_mark_gc() will return true
// for the duration of this pause.
g1_policy()->decide_on_conc_mark_initiation();
}
< prev index next >