mirror of
https://github.com/openjdk/jdk.git
synced 2026-03-31 02:00:02 +00:00
8244180: Shenandoah: carry Phase to ShWorkerTimingsTracker explicitly
Reviewed-by: zgu
This commit is contained in:
Aleksey Shipilev
parent
1e1c724c0d
commit
38e6f3665c
@ -346,7 +346,7 @@ private:
|
||||
public:
|
||||
ShenandoahUpdateThreadRootsTask(bool is_par, ShenandoahPhaseTimings::Phase phase) :
|
||||
AbstractGangTask("Shenandoah Update Thread Roots"),
|
||||
_thread_roots(is_par),
|
||||
_thread_roots(phase, is_par),
|
||||
_phase(phase),
|
||||
_worker_phase(phase) {}
|
||||
|
||||
|
||||
@ -1645,9 +1645,10 @@ private:
|
||||
ShenandoahConcurrentStringDedupRoots _dedup_roots;
|
||||
|
||||
public:
|
||||
ShenandoahConcurrentRootsEvacUpdateTask() :
|
||||
AbstractGangTask("Shenandoah Evacuate/Update Concurrent Strong Roots Task") {
|
||||
}
|
||||
ShenandoahConcurrentRootsEvacUpdateTask(ShenandoahPhaseTimings::Phase phase) :
|
||||
AbstractGangTask("Shenandoah Evacuate/Update Concurrent Strong Roots Task"),
|
||||
_vm_roots(phase),
|
||||
_cld_roots(phase) {}
|
||||
|
||||
void work(uint worker_id) {
|
||||
ShenandoahEvacOOMScope oom;
|
||||
@ -1761,12 +1762,13 @@ private:
|
||||
bool _concurrent_class_unloading;
|
||||
|
||||
public:
|
||||
ShenandoahConcurrentWeakRootsEvacUpdateTask() :
|
||||
ShenandoahConcurrentWeakRootsEvacUpdateTask(ShenandoahPhaseTimings::Phase phase) :
|
||||
AbstractGangTask("Shenandoah Concurrent Weak Root Task"),
|
||||
_jni_roots(OopStorageSet::jni_weak(), ShenandoahPhaseTimings::JNIWeakRoots),
|
||||
_string_table_roots(OopStorageSet::string_table_weak(), ShenandoahPhaseTimings::StringTableRoots),
|
||||
_resolved_method_table_roots(OopStorageSet::resolved_method_table_weak(), ShenandoahPhaseTimings::ResolvedMethodTableRoots),
|
||||
_vm_roots(OopStorageSet::vm_weak(), ShenandoahPhaseTimings::VMWeakRoots),
|
||||
_jni_roots(OopStorageSet::jni_weak(), phase, ShenandoahPhaseTimings::JNIWeakRoots),
|
||||
_string_table_roots(OopStorageSet::string_table_weak(), phase, ShenandoahPhaseTimings::StringTableRoots),
|
||||
_resolved_method_table_roots(OopStorageSet::resolved_method_table_weak(), phase, ShenandoahPhaseTimings::ResolvedMethodTableRoots),
|
||||
_vm_roots(OopStorageSet::vm_weak(), phase, ShenandoahPhaseTimings::VMWeakRoots),
|
||||
_cld_roots(phase),
|
||||
_nmethod_itr(ShenandoahCodeRoots::table()),
|
||||
_concurrent_class_unloading(ShenandoahConcurrentRoots::should_do_concurrent_class_unloading()) {
|
||||
StringTable::reset_dead_counter();
|
||||
@ -1826,7 +1828,7 @@ public:
|
||||
void ShenandoahHeap::op_weak_roots() {
|
||||
if (is_concurrent_weak_root_in_progress()) {
|
||||
// Concurrent weak root processing
|
||||
ShenandoahConcurrentWeakRootsEvacUpdateTask task;
|
||||
ShenandoahConcurrentWeakRootsEvacUpdateTask task(ShenandoahPhaseTimings::conc_weak_roots);
|
||||
workers()->run_task(&task);
|
||||
if (!ShenandoahConcurrentRoots::should_do_concurrent_class_unloading()) {
|
||||
set_concurrent_weak_root_in_progress(false);
|
||||
@ -1844,7 +1846,7 @@ void ShenandoahHeap::op_class_unloading() {
|
||||
|
||||
void ShenandoahHeap::op_strong_roots() {
|
||||
assert(is_concurrent_strong_root_in_progress(), "Checked by caller");
|
||||
ShenandoahConcurrentRootsEvacUpdateTask task;
|
||||
ShenandoahConcurrentRootsEvacUpdateTask task(ShenandoahPhaseTimings::conc_strong_roots);
|
||||
workers()->run_task(&task);
|
||||
set_concurrent_strong_root_in_progress(false);
|
||||
}
|
||||
@ -2243,17 +2245,17 @@ void ShenandoahHeap::stw_process_weak_roots(bool full_gc) {
|
||||
ShenandoahForwardedIsAliveClosure is_alive;
|
||||
ShenandoahUpdateRefsClosure keep_alive;
|
||||
ShenandoahParallelWeakRootsCleaningTask<ShenandoahForwardedIsAliveClosure, ShenandoahUpdateRefsClosure>
|
||||
cleaning_task(&is_alive, &keep_alive, num_workers, !ShenandoahConcurrentRoots::should_do_concurrent_class_unloading());
|
||||
cleaning_task(timing_phase, &is_alive, &keep_alive, num_workers, !ShenandoahConcurrentRoots::should_do_concurrent_class_unloading());
|
||||
_workers->run_task(&cleaning_task);
|
||||
} else {
|
||||
ShenandoahIsAliveClosure is_alive;
|
||||
#ifdef ASSERT
|
||||
ShenandoahAssertNotForwardedClosure verify_cl;
|
||||
ShenandoahParallelWeakRootsCleaningTask<ShenandoahIsAliveClosure, ShenandoahAssertNotForwardedClosure>
|
||||
cleaning_task(&is_alive, &verify_cl, num_workers, !ShenandoahConcurrentRoots::should_do_concurrent_class_unloading());
|
||||
cleaning_task(timing_phase, &is_alive, &verify_cl, num_workers, !ShenandoahConcurrentRoots::should_do_concurrent_class_unloading());
|
||||
#else
|
||||
ShenandoahParallelWeakRootsCleaningTask<ShenandoahIsAliveClosure, DoNothingClosure>
|
||||
cleaning_task(&is_alive, &do_nothing_cl, num_workers, !ShenandoahConcurrentRoots::should_do_concurrent_class_unloading());
|
||||
cleaning_task(timing_phase, &is_alive, &do_nothing_cl, num_workers, !ShenandoahConcurrentRoots::should_do_concurrent_class_unloading());
|
||||
#endif
|
||||
_workers->run_task(&cleaning_task);
|
||||
}
|
||||
|
||||
@ -36,6 +36,7 @@
|
||||
template <typename IsAlive, typename KeepAlive>
|
||||
class ShenandoahParallelWeakRootsCleaningTask : public AbstractGangTask {
|
||||
protected:
|
||||
ShenandoahPhaseTimings::Phase _phase;
|
||||
WeakProcessor::Task _weak_processing_task;
|
||||
ShenandoahSerialWeakRoots _serial_weak_roots;
|
||||
IsAlive* _is_alive;
|
||||
@ -43,7 +44,8 @@ protected:
|
||||
bool _include_concurrent_roots;
|
||||
|
||||
public:
|
||||
ShenandoahParallelWeakRootsCleaningTask(IsAlive* is_alive,
|
||||
ShenandoahParallelWeakRootsCleaningTask(ShenandoahPhaseTimings::Phase phase,
|
||||
IsAlive* is_alive,
|
||||
KeepAlive* keep_alive,
|
||||
uint num_workers,
|
||||
bool include_concurrent_roots);
|
||||
|
||||
@ -33,12 +33,13 @@
|
||||
#include "runtime/safepoint.hpp"
|
||||
|
||||
template<typename IsAlive, typename KeepAlive>
|
||||
ShenandoahParallelWeakRootsCleaningTask<IsAlive, KeepAlive>::ShenandoahParallelWeakRootsCleaningTask(IsAlive* is_alive,
|
||||
ShenandoahParallelWeakRootsCleaningTask<IsAlive, KeepAlive>::ShenandoahParallelWeakRootsCleaningTask(ShenandoahPhaseTimings::Phase phase,
|
||||
IsAlive* is_alive,
|
||||
KeepAlive* keep_alive,
|
||||
uint num_workers,
|
||||
bool include_concurrent_roots) :
|
||||
AbstractGangTask("Parallel Weak Root Cleaning Task"),
|
||||
_weak_processing_task(num_workers),
|
||||
_phase(phase), _weak_processing_task(num_workers), _serial_weak_roots(phase),
|
||||
_is_alive(is_alive), _keep_alive(keep_alive), _include_concurrent_roots(include_concurrent_roots) {
|
||||
assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
|
||||
|
||||
@ -63,7 +64,7 @@ void ShenandoahParallelWeakRootsCleaningTask<IsAlive, KeepAlive>::work(uint work
|
||||
}
|
||||
|
||||
if (ShenandoahStringDedup::is_enabled()) {
|
||||
ShenandoahStringDedup::parallel_oops_do(_is_alive, _keep_alive, worker_id);
|
||||
ShenandoahStringDedup::parallel_oops_do(_phase, _is_alive, _keep_alive, worker_id);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -75,8 +75,6 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
|
||||
|
||||
_policy = ShenandoahHeap::heap()->shenandoah_policy();
|
||||
assert(_policy != NULL, "Can not be NULL");
|
||||
|
||||
_current_worker_phase = _invalid_phase;
|
||||
}
|
||||
|
||||
ShenandoahPhaseTimings::Phase ShenandoahPhaseTimings::worker_par_phase(Phase phase, ParPhase par_phase) {
|
||||
@ -115,6 +113,22 @@ bool ShenandoahPhaseTimings::is_worker_phase(Phase phase) {
|
||||
}
|
||||
}
|
||||
|
||||
bool ShenandoahPhaseTimings::is_root_work_phase(Phase phase) {
|
||||
switch (phase) {
|
||||
case scan_roots:
|
||||
case update_roots:
|
||||
case init_evac:
|
||||
case final_update_refs_roots:
|
||||
case degen_gc_update_roots:
|
||||
case full_gc_scan_roots:
|
||||
case full_gc_update_roots:
|
||||
case full_gc_adjust_roots:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void ShenandoahPhaseTimings::set_cycle_data(Phase phase, double time) {
|
||||
#ifdef ASSERT
|
||||
double d = _cycle_data[phase];
|
||||
@ -132,10 +146,6 @@ void ShenandoahPhaseTimings::record_phase_time(Phase phase, double time) {
|
||||
void ShenandoahPhaseTimings::record_workers_start(Phase phase) {
|
||||
assert(is_worker_phase(phase), "Phase should accept worker phase times: %s", phase_name(phase));
|
||||
|
||||
assert(_current_worker_phase == _invalid_phase, "Should not be set yet: requested %s, existing %s",
|
||||
phase_name(phase), phase_name(_current_worker_phase));
|
||||
_current_worker_phase = phase;
|
||||
|
||||
for (uint i = 1; i < _num_par_phases; i++) {
|
||||
worker_data(phase, ParPhase(i))->reset();
|
||||
}
|
||||
@ -143,7 +153,6 @@ void ShenandoahPhaseTimings::record_workers_start(Phase phase) {
|
||||
|
||||
void ShenandoahPhaseTimings::record_workers_end(Phase phase) {
|
||||
assert(is_worker_phase(phase), "Phase should accept worker phase times: %s", phase_name(phase));
|
||||
_current_worker_phase = _invalid_phase;
|
||||
}
|
||||
|
||||
void ShenandoahPhaseTimings::flush_par_workers_to_cycle() {
|
||||
@ -233,9 +242,11 @@ void ShenandoahPhaseTimings::print_global_on(outputStream* out) const {
|
||||
}
|
||||
}
|
||||
|
||||
ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id) :
|
||||
_timings(ShenandoahHeap::heap()->phase_timings()), _phase(_timings->current_worker_phase()),
|
||||
_par_phase(par_phase), _worker_id(worker_id) {
|
||||
ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::Phase phase,
|
||||
ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id) :
|
||||
_timings(ShenandoahHeap::heap()->phase_timings()),
|
||||
_phase(phase), _par_phase(par_phase), _worker_id(worker_id) {
|
||||
|
||||
assert(_timings->worker_data(_phase, _par_phase)->get(_worker_id) == ShenandoahWorkerData::uninitialized(),
|
||||
"Should not be set yet: %s", ShenandoahPhaseTimings::phase_name(_timings->worker_par_phase(_phase, _par_phase)));
|
||||
_start_time = os::elapsedTime();
|
||||
@ -244,8 +255,8 @@ ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahPhaseTi
|
||||
ShenandoahWorkerTimingsTracker::~ShenandoahWorkerTimingsTracker() {
|
||||
_timings->worker_data(_phase, _par_phase)->set(_worker_id, os::elapsedTime() - _start_time);
|
||||
|
||||
if (ShenandoahGCPhase::is_root_work_phase()) {
|
||||
ShenandoahPhaseTimings::Phase root_phase = ShenandoahGCPhase::current_phase();
|
||||
if (ShenandoahPhaseTimings::is_root_work_phase(_phase)) {
|
||||
ShenandoahPhaseTimings::Phase root_phase = _phase;
|
||||
ShenandoahPhaseTimings::Phase cur_phase = _timings->worker_par_phase(root_phase, _par_phase);
|
||||
_event.commit(GCId::current(), _worker_id, ShenandoahPhaseTimings::phase_name(cur_phase));
|
||||
}
|
||||
|
||||
@ -183,12 +183,11 @@ private:
|
||||
HdrSeq _global_data[_num_phases];
|
||||
static const char* _phase_names[_num_phases];
|
||||
|
||||
Phase _current_worker_phase;
|
||||
ShenandoahWorkerData* _worker_data[_num_phases];
|
||||
ShenandoahCollectorPolicy* _policy;
|
||||
|
||||
static bool is_worker_phase(Phase phase);
|
||||
Phase current_worker_phase() { return _current_worker_phase; }
|
||||
static bool is_root_work_phase(Phase phase);
|
||||
|
||||
ShenandoahWorkerData* worker_data(Phase phase, ParPhase par_phase);
|
||||
Phase worker_par_phase(Phase phase, ParPhase par_phase);
|
||||
@ -225,7 +224,7 @@ private:
|
||||
double _start_time;
|
||||
EventGCPhaseParallel _event;
|
||||
public:
|
||||
ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id);
|
||||
ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id);
|
||||
~ShenandoahWorkerTimingsTracker();
|
||||
};
|
||||
|
||||
|
||||
@ -42,13 +42,14 @@
|
||||
#include "runtime/thread.hpp"
|
||||
#include "services/management.hpp"
|
||||
|
||||
ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_oops_do(oops_do), _par_phase(par_phase) {
|
||||
ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_oops_do(oops_do), _phase(phase), _par_phase(par_phase) {
|
||||
}
|
||||
|
||||
void ShenandoahSerialRoot::oops_do(OopClosure* cl, uint worker_id) {
|
||||
if (_claimed.try_set()) {
|
||||
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
|
||||
_oops_do(cl);
|
||||
}
|
||||
}
|
||||
@ -58,12 +59,12 @@ static void system_dictionary_oops_do(OopClosure* cl) {
|
||||
SystemDictionary::oops_do(cl, false);
|
||||
}
|
||||
|
||||
ShenandoahSerialRoots::ShenandoahSerialRoots() :
|
||||
_universe_root(&Universe::oops_do, ShenandoahPhaseTimings::UniverseRoots),
|
||||
_object_synchronizer_root(&ObjectSynchronizer::oops_do, ShenandoahPhaseTimings::ObjectSynchronizerRoots),
|
||||
_management_root(&Management::oops_do, ShenandoahPhaseTimings::ManagementRoots),
|
||||
_system_dictionary_root(&system_dictionary_oops_do, ShenandoahPhaseTimings::SystemDictionaryRoots),
|
||||
_jvmti_root(&JvmtiExport::oops_do, ShenandoahPhaseTimings::JVMTIRoots) {
|
||||
ShenandoahSerialRoots::ShenandoahSerialRoots(ShenandoahPhaseTimings::Phase phase) :
|
||||
_universe_root(&Universe::oops_do, phase, ShenandoahPhaseTimings::UniverseRoots),
|
||||
_object_synchronizer_root(&ObjectSynchronizer::oops_do, phase, ShenandoahPhaseTimings::ObjectSynchronizerRoots),
|
||||
_management_root(&Management::oops_do, phase, ShenandoahPhaseTimings::ManagementRoots),
|
||||
_system_dictionary_root(&system_dictionary_oops_do, phase, ShenandoahPhaseTimings::SystemDictionaryRoots),
|
||||
_jvmti_root(&JvmtiExport::oops_do, phase, ShenandoahPhaseTimings::JVMTIRoots) {
|
||||
}
|
||||
|
||||
void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
|
||||
@ -74,26 +75,27 @@ void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
|
||||
_jvmti_root.oops_do(cl, worker_id);
|
||||
}
|
||||
|
||||
ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_weak_oops_do(weak_oops_do), _par_phase(par_phase) {
|
||||
ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_weak_oops_do(weak_oops_do), _phase(phase), _par_phase(par_phase) {
|
||||
}
|
||||
|
||||
void ShenandoahWeakSerialRoot::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
|
||||
if (_claimed.try_set()) {
|
||||
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
|
||||
_weak_oops_do(is_alive, keep_alive);
|
||||
}
|
||||
}
|
||||
|
||||
#if INCLUDE_JVMTI
|
||||
ShenandoahJVMTIWeakRoot::ShenandoahJVMTIWeakRoot() :
|
||||
ShenandoahWeakSerialRoot(&JvmtiExport::weak_oops_do, ShenandoahPhaseTimings::JVMTIWeakRoots) {
|
||||
ShenandoahJVMTIWeakRoot::ShenandoahJVMTIWeakRoot(ShenandoahPhaseTimings::Phase phase) :
|
||||
ShenandoahWeakSerialRoot(&JvmtiExport::weak_oops_do, phase, ShenandoahPhaseTimings::JVMTIWeakRoots) {
|
||||
}
|
||||
#endif // INCLUDE_JVMTI
|
||||
|
||||
#if INCLUDE_JFR
|
||||
ShenandoahJFRWeakRoot::ShenandoahJFRWeakRoot() :
|
||||
ShenandoahWeakSerialRoot(&Jfr::weak_oops_do, ShenandoahPhaseTimings::JFRWeakRoots) {
|
||||
ShenandoahJFRWeakRoot::ShenandoahJFRWeakRoot(ShenandoahPhaseTimings::Phase phase) :
|
||||
ShenandoahWeakSerialRoot(&Jfr::weak_oops_do, phase, ShenandoahPhaseTimings::JFRWeakRoots) {
|
||||
}
|
||||
#endif // INCLUDE_JFR
|
||||
|
||||
@ -107,18 +109,19 @@ void ShenandoahSerialWeakRoots::weak_oops_do(OopClosure* cl, uint worker_id) {
|
||||
weak_oops_do(&always_true, cl, worker_id);
|
||||
}
|
||||
|
||||
ShenandoahThreadRoots::ShenandoahThreadRoots(bool is_par) : _is_par(is_par) {
|
||||
ShenandoahThreadRoots::ShenandoahThreadRoots(ShenandoahPhaseTimings::Phase phase, bool is_par) :
|
||||
_phase(phase), _is_par(is_par) {
|
||||
Threads::change_thread_claim_token();
|
||||
}
|
||||
|
||||
void ShenandoahThreadRoots::oops_do(OopClosure* oops_cl, CodeBlobClosure* code_cl, uint worker_id) {
|
||||
ShenandoahWorkerTimingsTracker timer(ShenandoahPhaseTimings::ThreadRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::ThreadRoots, worker_id);
|
||||
ResourceMark rm;
|
||||
Threads::possibly_parallel_oops_do(_is_par, oops_cl, code_cl);
|
||||
}
|
||||
|
||||
void ShenandoahThreadRoots::threads_do(ThreadClosure* tc, uint worker_id) {
|
||||
ShenandoahWorkerTimingsTracker timer(ShenandoahPhaseTimings::ThreadRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::ThreadRoots, worker_id);
|
||||
ResourceMark rm;
|
||||
Threads::possibly_parallel_threads_do(_is_par, tc);
|
||||
}
|
||||
@ -127,7 +130,7 @@ ShenandoahThreadRoots::~ShenandoahThreadRoots() {
|
||||
Threads::assert_all_threads_claimed();
|
||||
}
|
||||
|
||||
ShenandoahStringDedupRoots::ShenandoahStringDedupRoots() {
|
||||
ShenandoahStringDedupRoots::ShenandoahStringDedupRoots(ShenandoahPhaseTimings::Phase phase) : _phase(phase) {
|
||||
if (ShenandoahStringDedup::is_enabled()) {
|
||||
StringDedup::gc_prologue(false);
|
||||
}
|
||||
@ -141,7 +144,7 @@ ShenandoahStringDedupRoots::~ShenandoahStringDedupRoots() {
|
||||
|
||||
void ShenandoahStringDedupRoots::oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
|
||||
if (ShenandoahStringDedup::is_enabled()) {
|
||||
ShenandoahStringDedup::parallel_oops_do(is_alive, keep_alive, worker_id);
|
||||
ShenandoahStringDedup::parallel_oops_do(_phase, is_alive, keep_alive, worker_id);
|
||||
}
|
||||
}
|
||||
|
||||
@ -184,7 +187,14 @@ ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers,
|
||||
bool stw_roots_processing,
|
||||
bool stw_class_unloading) :
|
||||
ShenandoahRootProcessor(phase),
|
||||
_thread_roots(n_workers > 1),
|
||||
_serial_roots(phase),
|
||||
_vm_roots(phase),
|
||||
_cld_roots(phase),
|
||||
_thread_roots(phase, n_workers > 1),
|
||||
_serial_weak_roots(phase),
|
||||
_weak_roots(phase),
|
||||
_dedup_roots(phase),
|
||||
_code_roots(phase),
|
||||
_stw_roots_processing(stw_roots_processing),
|
||||
_stw_class_unloading(stw_class_unloading) {
|
||||
}
|
||||
@ -217,12 +227,26 @@ void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
|
||||
|
||||
ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
|
||||
ShenandoahRootProcessor(phase),
|
||||
_thread_roots(n_workers > 1) {
|
||||
_serial_roots(phase),
|
||||
_vm_roots(phase),
|
||||
_cld_roots(phase),
|
||||
_thread_roots(phase, n_workers > 1),
|
||||
_serial_weak_roots(phase),
|
||||
_weak_roots(phase),
|
||||
_dedup_roots(phase),
|
||||
_code_roots(phase) {
|
||||
}
|
||||
|
||||
ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
|
||||
ShenandoahRootProcessor(phase),
|
||||
_thread_roots(n_workers > 1) {
|
||||
_serial_roots(phase),
|
||||
_vm_roots(phase),
|
||||
_cld_roots(phase),
|
||||
_thread_roots(phase, n_workers > 1),
|
||||
_serial_weak_roots(phase),
|
||||
_weak_roots(phase),
|
||||
_dedup_roots(phase),
|
||||
_code_roots(phase) {
|
||||
assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
|
||||
}
|
||||
|
||||
@ -247,9 +271,15 @@ void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
|
||||
_dedup_roots.oops_do(&always_true, oops, worker_id);
|
||||
}
|
||||
|
||||
ShenandoahHeapIterationRootScanner::ShenandoahHeapIterationRootScanner() :
|
||||
ShenandoahHeapIterationRootScanner::ShenandoahHeapIterationRootScanner() :
|
||||
ShenandoahRootProcessor(ShenandoahPhaseTimings::heap_iteration_roots),
|
||||
_thread_roots(false /*is par*/) {
|
||||
_serial_roots(ShenandoahPhaseTimings::heap_iteration_roots),
|
||||
_thread_roots(ShenandoahPhaseTimings::heap_iteration_roots, false /*is par*/),
|
||||
_vm_roots(ShenandoahPhaseTimings::heap_iteration_roots),
|
||||
_cld_roots(ShenandoahPhaseTimings::heap_iteration_roots),
|
||||
_serial_weak_roots(ShenandoahPhaseTimings::heap_iteration_roots),
|
||||
_weak_roots(ShenandoahPhaseTimings::heap_iteration_roots),
|
||||
_code_roots(ShenandoahPhaseTimings::heap_iteration_roots) {
|
||||
}
|
||||
|
||||
void ShenandoahHeapIterationRootScanner::roots_do(OopClosure* oops) {
|
||||
|
||||
@ -40,10 +40,12 @@ public:
|
||||
private:
|
||||
ShenandoahSharedFlag _claimed;
|
||||
const OopsDo _oops_do;
|
||||
const ShenandoahPhaseTimings::Phase _phase;
|
||||
const ShenandoahPhaseTimings::ParPhase _par_phase;
|
||||
|
||||
public:
|
||||
ShenandoahSerialRoot(OopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
ShenandoahSerialRoot(OopsDo oops_do,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
void oops_do(OopClosure* cl, uint worker_id);
|
||||
};
|
||||
|
||||
@ -55,7 +57,7 @@ private:
|
||||
ShenandoahSerialRoot _system_dictionary_root;
|
||||
ShenandoahSerialRoot _jvmti_root;
|
||||
public:
|
||||
ShenandoahSerialRoots();
|
||||
ShenandoahSerialRoots(ShenandoahPhaseTimings::Phase phase);
|
||||
void oops_do(OopClosure* cl, uint worker_id);
|
||||
};
|
||||
|
||||
@ -64,24 +66,26 @@ class ShenandoahWeakSerialRoot {
|
||||
private:
|
||||
ShenandoahSharedFlag _claimed;
|
||||
const WeakOopsDo _weak_oops_do;
|
||||
const ShenandoahPhaseTimings::Phase _phase;
|
||||
const ShenandoahPhaseTimings::ParPhase _par_phase;
|
||||
|
||||
public:
|
||||
ShenandoahWeakSerialRoot(WeakOopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
ShenandoahWeakSerialRoot(WeakOopsDo oops_do,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id);
|
||||
};
|
||||
|
||||
#if INCLUDE_JVMTI
|
||||
class ShenandoahJVMTIWeakRoot : public ShenandoahWeakSerialRoot {
|
||||
public:
|
||||
ShenandoahJVMTIWeakRoot();
|
||||
ShenandoahJVMTIWeakRoot(ShenandoahPhaseTimings::Phase phase);
|
||||
};
|
||||
#endif // INCLUDE_JVMTI
|
||||
|
||||
#if INCLUDE_JFR
|
||||
class ShenandoahJFRWeakRoot : public ShenandoahWeakSerialRoot {
|
||||
public:
|
||||
ShenandoahJFRWeakRoot();
|
||||
ShenandoahJFRWeakRoot(ShenandoahPhaseTimings::Phase phase);
|
||||
};
|
||||
#endif // INCLUDE_JFR
|
||||
|
||||
@ -90,6 +94,9 @@ private:
|
||||
JVMTI_ONLY(ShenandoahJVMTIWeakRoot _jvmti_weak_roots;)
|
||||
JFR_ONLY(ShenandoahJFRWeakRoot _jfr_weak_roots;)
|
||||
public:
|
||||
ShenandoahSerialWeakRoots(ShenandoahPhaseTimings::Phase phase) :
|
||||
JVMTI_ONLY(_jvmti_weak_roots(phase))
|
||||
JFR_ONLY(JVMTI_ONLY(COMMA)_jfr_weak_roots(phase)) {};
|
||||
void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id);
|
||||
void weak_oops_do(OopClosure* cl, uint worker_id);
|
||||
};
|
||||
@ -98,9 +105,11 @@ template <bool CONCURRENT>
|
||||
class ShenandoahVMRoot {
|
||||
private:
|
||||
OopStorage::ParState<CONCURRENT, false /* is_const */> _itr;
|
||||
const ShenandoahPhaseTimings::Phase _phase;
|
||||
const ShenandoahPhaseTimings::ParPhase _par_phase;
|
||||
public:
|
||||
ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
ShenandoahVMRoot(OopStorage* storage,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
|
||||
template <typename Closure>
|
||||
void oops_do(Closure* cl, uint worker_id);
|
||||
@ -109,17 +118,20 @@ public:
|
||||
template <bool CONCURRENT>
|
||||
class ShenandoahWeakRoot : public ShenandoahVMRoot<CONCURRENT> {
|
||||
public:
|
||||
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
ShenandoahWeakRoot(OopStorage* storage,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
};
|
||||
|
||||
template <>
|
||||
class ShenandoahWeakRoot<false /*concurrent*/> {
|
||||
private:
|
||||
OopStorage::ParState<false /*concurrent*/, false /*is_const*/> _itr;
|
||||
const ShenandoahPhaseTimings::Phase _phase;
|
||||
const ShenandoahPhaseTimings::ParPhase _par_phase;
|
||||
|
||||
public:
|
||||
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
ShenandoahWeakRoot(OopStorage* storage,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase);
|
||||
|
||||
template <typename IsAliveClosure, typename KeepAliveClosure>
|
||||
void weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id);
|
||||
@ -148,7 +160,7 @@ private:
|
||||
ShenandoahWeakRoot<false /*concurrent*/> _resolved_method_table_roots;
|
||||
ShenandoahWeakRoot<false /*concurrent*/> _vm_roots;
|
||||
public:
|
||||
ShenandoahWeakRoots();
|
||||
ShenandoahWeakRoots(ShenandoahPhaseTimings::Phase phase);
|
||||
|
||||
template <typename Closure>
|
||||
void oops_do(Closure* cl, uint worker_id);
|
||||
@ -164,7 +176,7 @@ private:
|
||||
ShenandoahVMRoot<CONCURRENT> _vm_global_roots;
|
||||
|
||||
public:
|
||||
ShenandoahVMRoots();
|
||||
ShenandoahVMRoots(ShenandoahPhaseTimings::Phase phase);
|
||||
|
||||
template <typename T>
|
||||
void oops_do(T* cl, uint worker_id);
|
||||
@ -172,9 +184,10 @@ public:
|
||||
|
||||
class ShenandoahThreadRoots {
|
||||
private:
|
||||
ShenandoahPhaseTimings::Phase _phase;
|
||||
const bool _is_par;
|
||||
public:
|
||||
ShenandoahThreadRoots(bool is_par);
|
||||
ShenandoahThreadRoots(ShenandoahPhaseTimings::Phase phase, bool is_par);
|
||||
~ShenandoahThreadRoots();
|
||||
|
||||
void oops_do(OopClosure* oops_cl, CodeBlobClosure* code_cl, uint worker_id);
|
||||
@ -182,8 +195,10 @@ public:
|
||||
};
|
||||
|
||||
class ShenandoahStringDedupRoots {
|
||||
private:
|
||||
ShenandoahPhaseTimings::Phase _phase;
|
||||
public:
|
||||
ShenandoahStringDedupRoots();
|
||||
ShenandoahStringDedupRoots(ShenandoahPhaseTimings::Phase phase);
|
||||
~ShenandoahStringDedupRoots();
|
||||
|
||||
void oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id);
|
||||
@ -200,9 +215,10 @@ public:
|
||||
template <typename ITR>
|
||||
class ShenandoahCodeCacheRoots {
|
||||
private:
|
||||
ShenandoahPhaseTimings::Phase _phase;
|
||||
ITR _coderoots_iterator;
|
||||
public:
|
||||
ShenandoahCodeCacheRoots();
|
||||
ShenandoahCodeCacheRoots(ShenandoahPhaseTimings::Phase phase);
|
||||
~ShenandoahCodeCacheRoots();
|
||||
|
||||
void code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id);
|
||||
@ -210,8 +226,10 @@ public:
|
||||
|
||||
template <bool CONCURRENT, bool SINGLE_THREADED>
|
||||
class ShenandoahClassLoaderDataRoots {
|
||||
private:
|
||||
ShenandoahPhaseTimings::Phase _phase;
|
||||
public:
|
||||
ShenandoahClassLoaderDataRoots();
|
||||
ShenandoahClassLoaderDataRoots(ShenandoahPhaseTimings::Phase phase);
|
||||
~ShenandoahClassLoaderDataRoots();
|
||||
|
||||
void always_strong_cld_do(CLDClosure* clds, uint worker_id);
|
||||
|
||||
@ -40,8 +40,9 @@
|
||||
#include "runtime/safepoint.hpp"
|
||||
|
||||
template <bool CONCURRENT>
|
||||
inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_itr(storage), _par_phase(par_phase) {
|
||||
inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_itr(storage), _phase(phase), _par_phase(par_phase) {
|
||||
}
|
||||
|
||||
template <bool CONCURRENT>
|
||||
@ -50,23 +51,25 @@ inline void ShenandoahVMRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
|
||||
if (CONCURRENT) {
|
||||
_itr.oops_do(cl);
|
||||
} else {
|
||||
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
|
||||
_itr.oops_do(cl);
|
||||
}
|
||||
}
|
||||
|
||||
template <bool CONCURRENT>
|
||||
inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
ShenandoahVMRoot<CONCURRENT>(storage, par_phase) {
|
||||
inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
ShenandoahVMRoot<CONCURRENT>(storage, phase, par_phase) {
|
||||
}
|
||||
|
||||
inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_itr(storage), _par_phase(par_phase) {
|
||||
inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage,
|
||||
ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
|
||||
_itr(storage), _phase(phase), _par_phase(par_phase) {
|
||||
}
|
||||
|
||||
template <typename IsAliveClosure, typename KeepAliveClosure>
|
||||
void ShenandoahWeakRoot<false /* concurrent */>::weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id) {
|
||||
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
|
||||
_itr.weak_oops_do(is_alive, keep_alive);
|
||||
}
|
||||
|
||||
@ -87,11 +90,11 @@ void ShenandoahWeakRoots<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
|
||||
_vm_roots.oops_do(cl, worker_id);
|
||||
}
|
||||
|
||||
inline ShenandoahWeakRoots<false /* concurrent */>::ShenandoahWeakRoots() :
|
||||
_jni_roots(OopStorageSet::jni_weak(), ShenandoahPhaseTimings::JNIWeakRoots),
|
||||
_string_table_roots(OopStorageSet::string_table_weak(), ShenandoahPhaseTimings::StringTableRoots),
|
||||
_resolved_method_table_roots(OopStorageSet::resolved_method_table_weak(), ShenandoahPhaseTimings::ResolvedMethodTableRoots),
|
||||
_vm_roots(OopStorageSet::vm_weak(), ShenandoahPhaseTimings::VMWeakRoots) {
|
||||
inline ShenandoahWeakRoots<false /* concurrent */>::ShenandoahWeakRoots(ShenandoahPhaseTimings::Phase phase) :
|
||||
_jni_roots(OopStorageSet::jni_weak(), phase, ShenandoahPhaseTimings::JNIWeakRoots),
|
||||
_string_table_roots(OopStorageSet::string_table_weak(), phase, ShenandoahPhaseTimings::StringTableRoots),
|
||||
_resolved_method_table_roots(OopStorageSet::resolved_method_table_weak(), phase, ShenandoahPhaseTimings::ResolvedMethodTableRoots),
|
||||
_vm_roots(OopStorageSet::vm_weak(), phase, ShenandoahPhaseTimings::VMWeakRoots) {
|
||||
}
|
||||
|
||||
template <typename IsAliveClosure, typename KeepAliveClosure>
|
||||
@ -109,9 +112,9 @@ void ShenandoahWeakRoots<false /* concurrent */>::oops_do(Closure* cl, uint work
|
||||
}
|
||||
|
||||
template <bool CONCURRENT>
|
||||
ShenandoahVMRoots<CONCURRENT>::ShenandoahVMRoots() :
|
||||
_jni_handle_roots(OopStorageSet::jni_global(), ShenandoahPhaseTimings::JNIRoots),
|
||||
_vm_global_roots(OopStorageSet::vm_global(), ShenandoahPhaseTimings::VMGlobalRoots) {
|
||||
ShenandoahVMRoots<CONCURRENT>::ShenandoahVMRoots(ShenandoahPhaseTimings::Phase phase) :
|
||||
_jni_handle_roots(OopStorageSet::jni_global(), phase, ShenandoahPhaseTimings::JNIRoots),
|
||||
_vm_global_roots(OopStorageSet::vm_global(), phase, ShenandoahPhaseTimings::VMGlobalRoots) {
|
||||
}
|
||||
|
||||
template <bool CONCURRENT>
|
||||
@ -122,7 +125,8 @@ void ShenandoahVMRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
|
||||
}
|
||||
|
||||
template <bool CONCURRENT, bool SINGLE_THREADED>
|
||||
ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::ShenandoahClassLoaderDataRoots() {
|
||||
ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::ShenandoahClassLoaderDataRoots(ShenandoahPhaseTimings::Phase phase) :
|
||||
_phase(phase) {
|
||||
if (!SINGLE_THREADED) {
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
}
|
||||
@ -148,7 +152,7 @@ void ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::always_strong_
|
||||
} else if (CONCURRENT) {
|
||||
ClassLoaderDataGraph::always_strong_cld_do(clds);
|
||||
} else {
|
||||
ShenandoahWorkerTimingsTracker timer(ShenandoahPhaseTimings::CLDGRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::CLDGRoots, worker_id);
|
||||
ClassLoaderDataGraph::always_strong_cld_do(clds);
|
||||
}
|
||||
}
|
||||
@ -162,19 +166,19 @@ void ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::cld_do(CLDClos
|
||||
} else if (CONCURRENT) {
|
||||
ClassLoaderDataGraph::cld_do(clds);
|
||||
} else {
|
||||
ShenandoahWorkerTimingsTracker timer(ShenandoahPhaseTimings::CLDGRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::CLDGRoots, worker_id);
|
||||
ClassLoaderDataGraph::cld_do(clds);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename ITR>
|
||||
ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() {
|
||||
ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots(ShenandoahPhaseTimings::Phase phase) : _phase(phase) {
|
||||
nmethod::oops_do_marking_prologue();
|
||||
}
|
||||
|
||||
template <typename ITR>
|
||||
void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) {
|
||||
ShenandoahWorkerTimingsTracker timer(ShenandoahPhaseTimings::CodeCacheRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::CodeCacheRoots, worker_id);
|
||||
_coderoots_iterator.possibly_parallel_blobs_do(blob_cl);
|
||||
}
|
||||
|
||||
@ -203,7 +207,12 @@ public:
|
||||
template <typename ITR>
|
||||
ShenandoahRootScanner<ITR>::ShenandoahRootScanner(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
|
||||
ShenandoahRootProcessor(phase),
|
||||
_thread_roots(n_workers > 1) {
|
||||
_serial_roots(phase),
|
||||
_thread_roots(phase, n_workers > 1),
|
||||
_code_roots(phase),
|
||||
_vm_roots(phase),
|
||||
_dedup_roots(phase),
|
||||
_cld_roots(phase) {
|
||||
}
|
||||
|
||||
template <typename ITR>
|
||||
|
||||
@ -72,18 +72,19 @@ void ShenandoahStringDedup::deduplicate(oop java_string) {
|
||||
StringDedupTable::deduplicate(java_string, &dummy);
|
||||
}
|
||||
|
||||
void ShenandoahStringDedup::parallel_oops_do(BoolObjectClosure* is_alive, OopClosure* cl, uint worker_id) {
|
||||
void ShenandoahStringDedup::parallel_oops_do(ShenandoahPhaseTimings::Phase phase,
|
||||
BoolObjectClosure* is_alive, OopClosure* cl, uint worker_id) {
|
||||
assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
|
||||
assert(is_enabled(), "String deduplication not enabled");
|
||||
|
||||
StringDedupUnlinkOrOopsDoClosure sd_cl(is_alive, cl);
|
||||
{
|
||||
ShenandoahWorkerTimingsTracker x(ShenandoahPhaseTimings::StringDedupQueueRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker x(phase, ShenandoahPhaseTimings::StringDedupQueueRoots, worker_id);
|
||||
StringDedupQueue::unlink_or_oops_do(&sd_cl);
|
||||
}
|
||||
|
||||
{
|
||||
ShenandoahWorkerTimingsTracker x(ShenandoahPhaseTimings::StringDedupTableRoots, worker_id);
|
||||
ShenandoahWorkerTimingsTracker x(phase, ShenandoahPhaseTimings::StringDedupTableRoots, worker_id);
|
||||
StringDedupTable::unlink_or_oops_do(&sd_cl, worker_id);
|
||||
}
|
||||
}
|
||||
|
||||
@ -26,6 +26,7 @@
|
||||
#define SHARE_GC_SHENANDOAH_SHENANDOAHSTRINGDEDUP_HPP
|
||||
|
||||
#include "gc/shared/stringdedup/stringDedup.hpp"
|
||||
#include "gc/shenandoah/shenandoahPhaseTimings.hpp"
|
||||
#include "memory/iterator.hpp"
|
||||
|
||||
class ShenandoahStringDedup : public StringDedup {
|
||||
@ -39,7 +40,11 @@ public:
|
||||
// Deduplicate a string, the call is lock-free
|
||||
static void deduplicate(oop java_string);
|
||||
|
||||
static void parallel_oops_do(BoolObjectClosure* is_alive, OopClosure* cl, uint worker_id);
|
||||
static void parallel_oops_do(ShenandoahPhaseTimings::Phase phase,
|
||||
BoolObjectClosure* is_alive,
|
||||
OopClosure* cl,
|
||||
uint worker_id);
|
||||
|
||||
static void oops_do_slow(OopClosure* cl);
|
||||
|
||||
static inline bool is_candidate(oop obj);
|
||||
|
||||
@ -125,22 +125,6 @@ bool ShenandoahGCPhase::is_current_phase_valid() {
|
||||
return _current_phase < ShenandoahPhaseTimings::_num_phases;
|
||||
}
|
||||
|
||||
bool ShenandoahGCPhase::is_root_work_phase() {
|
||||
switch(current_phase()) {
|
||||
case ShenandoahPhaseTimings::scan_roots:
|
||||
case ShenandoahPhaseTimings::update_roots:
|
||||
case ShenandoahPhaseTimings::init_evac:
|
||||
case ShenandoahPhaseTimings::final_update_refs_roots:
|
||||
case ShenandoahPhaseTimings::degen_gc_update_roots:
|
||||
case ShenandoahPhaseTimings::full_gc_scan_roots:
|
||||
case ShenandoahPhaseTimings::full_gc_update_roots:
|
||||
case ShenandoahPhaseTimings::full_gc_adjust_roots:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
ShenandoahGCSubPhase::ShenandoahGCSubPhase(ShenandoahPhaseTimings::Phase phase) :
|
||||
ShenandoahGCPhase(phase),
|
||||
_timer(ShenandoahHeap::heap()->gc_timer()) {
|
||||
|
||||
@ -90,7 +90,6 @@ public:
|
||||
static ShenandoahPhaseTimings::Phase current_phase() { return _current_phase; }
|
||||
|
||||
static bool is_current_phase_valid();
|
||||
static bool is_root_work_phase();
|
||||
};
|
||||
|
||||
class ShenandoahGCSubPhase: public ShenandoahGCPhase {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user