stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8243573: Shenandoah: rename GCParPhases and related code

Browse Source 
Reviewed-by: rkennke
This commit is contained in:
Aleksey Shipilev 2020-04-30 10:02:10 +02:00
parent e513acab16
commit 05b3bc57ac
5 changed files with 66 additions and 66 deletions

24
src/hotspot/share/gc/shenandoah/shenandoahPhaseTimings.cpp

@ -38,14 +38,14 @@
#define SHENANDOAH_US_TIME_FORMAT "%8.0lf"
#define SHENANDOAH_US_WORKER_TIME_FORMAT "%3.0lf"
#define GC_PHASE_DECLARE_NAME(type, title) \
#define SHENANDOAH_PHASE_DECLARE_NAME(type, title) \
title,
const char* ShenandoahPhaseTimings::_phase_names[] = {
SHENANDOAH_GC_PHASE_DO(GC_PHASE_DECLARE_NAME)
SHENANDOAH_PHASE_DO(SHENANDOAH_PHASE_DECLARE_NAME)
};
#undef GC_PHASE_DECLARE_NAME
#undef SHENANDOAH_PHASE_DECLARE_NAME
ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
_max_workers(max_workers) {
@ -55,7 +55,7 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
for (uint i = 0; i < _num_phases; i++) {
#define SHENANDOAH_WORKER_DATA_NULL(type, title) \
_worker_data[i] = NULL;
SHENANDOAH_GC_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_NULL)
SHENANDOAH_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_NULL)
#undef SHENANDOAH_WORKER_DATA_NULL
_cycle_data[i] = 0;
}
@ -68,7 +68,7 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
int c = 0;
#define SHENANDOAH_WORKER_DATA_INIT(type, title) \
if (c++ != 0) _worker_data[i + c] = new ShenandoahWorkerData(title, _max_workers);
SHENANDOAH_GC_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_INIT)
SHENANDOAH_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_INIT)
#undef SHENANDOAH_WORKER_DATA_INIT
}
}
@ -79,14 +79,14 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
_current_worker_phase = _invalid_phase;
}
ShenandoahPhaseTimings::Phase ShenandoahPhaseTimings::worker_par_phase(Phase phase, GCParPhases par_phase) {
ShenandoahPhaseTimings::Phase ShenandoahPhaseTimings::worker_par_phase(Phase phase, ParPhase par_phase) {
assert(is_worker_phase(phase), "Phase should accept worker phase times: %s", phase_name(phase));
Phase p = Phase(phase + 1 + par_phase);
assert(p >= 0 && p < _num_phases, "Out of bound for: %s", phase_name(phase));
return p;
}
ShenandoahWorkerData* ShenandoahPhaseTimings::worker_data(Phase phase, GCParPhases par_phase) {
ShenandoahWorkerData* ShenandoahPhaseTimings::worker_data(Phase phase, ParPhase par_phase) {
Phase p = worker_par_phase(phase, par_phase);
ShenandoahWorkerData* wd = _worker_data[p];
assert(wd != NULL, "Counter initialized: %s", phase_name(p));
@ -136,8 +136,8 @@ void ShenandoahPhaseTimings::record_workers_start(Phase phase) {
phase_name(phase), phase_name(_current_worker_phase));
_current_worker_phase = phase;
for (uint i = 1; i < GCParPhasesSentinel; i++) {
worker_data(phase, GCParPhases(i))->reset();
for (uint i = 1; i < _num_par_phases; i++) {
worker_data(phase, ParPhase(i))->reset();
}
}
@ -151,8 +151,8 @@ void ShenandoahPhaseTimings::flush_par_workers_to_cycle() {
Phase phase = Phase(pi);
if (is_worker_phase(phase)) {
double s = 0;
for (uint i = 1; i < GCParPhasesSentinel; i++) {
double t = worker_data(phase, GCParPhases(i))->sum();
for (uint i = 1; i < _num_par_phases; i++) {
double t = worker_data(phase, ParPhase(i))->sum();
// add to each line in phase
set_cycle_data(Phase(phase + i + 1), t);
s += t;
@ -233,7 +233,7 @@ void ShenandoahPhaseTimings::print_global_on(outputStream* out) const {
}
}
ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::GCParPhases par_phase, uint worker_id) :
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) {
assert(_timings->worker_data(_phase, _par_phase)->get(_worker_id) == ShenandoahWorkerData::uninitialized(),

54
src/hotspot/share/gc/shenandoah/shenandoahPhaseTimings.hpp

@ -33,7 +33,7 @@
class ShenandoahCollectorPolicy;
class outputStream;
#define SHENANDOAH_GC_PAR_PHASE_DO(CNT_PREFIX, DESC_PREFIX, f) \
#define SHENANDOAH_PAR_PHASE_DO(CNT_PREFIX, DESC_PREFIX, f) \
f(CNT_PREFIX ## TotalWork, DESC_PREFIX "<total>") \
f(CNT_PREFIX ## ThreadRoots, DESC_PREFIX "Thread Roots") \
f(CNT_PREFIX ## CodeCacheRoots, DESC_PREFIX "Code Cache Roots") \
@ -56,7 +56,7 @@ class outputStream;
f(CNT_PREFIX ## FinishQueues, DESC_PREFIX "Finish Queues") \
// end
#define SHENANDOAH_GC_PHASE_DO(f) \
#define SHENANDOAH_PHASE_DO(f) \
f(conc_reset, "Concurrent Reset") \
\
f(init_mark_gross, "Pause Init Mark (G)") \
@ -64,7 +64,7 @@ class outputStream;
f(make_parsable, " Make Parsable") \
f(init_update_region_states, " Update Region States") \
f(scan_roots, " Scan Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(scan_, " S: ", f) \
SHENANDOAH_PAR_PHASE_DO(scan_, " S: ", f) \
f(resize_tlabs, " Resize TLABs") \
\
f(conc_mark, "Concurrent Marking") \
@ -73,22 +73,22 @@ class outputStream;
f(final_mark_gross, "Pause Final Mark (G)") \
f(final_mark, "Pause Final Mark (N)") \
f(update_roots, " Update Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(update_, " U: ", f) \
SHENANDOAH_PAR_PHASE_DO(update_, " U: ", f) \
f(finish_queues, " Finish Queues") \
f(weakrefs, " Weak References") \
f(weakrefs_process, " Process") \
f(purge, " System Purge") \
f(purge_class_unload, " Unload Classes") \
SHENANDOAH_GC_PAR_PHASE_DO(purge_cu_par_, " CU: ", f) \
SHENANDOAH_PAR_PHASE_DO(purge_cu_par_, " CU: ", f) \
f(purge_weak_par, " Weak Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(purge_weak_par_, " WR: ", f) \
SHENANDOAH_PAR_PHASE_DO(purge_weak_par_, " WR: ", f) \
f(purge_cldg, " CLDG") \
f(final_update_region_states, " Update Region States") \
f(retire_tlabs, " Retire TLABs") \
f(choose_cset, " Choose Collection Set") \
f(final_rebuild_freeset, " Rebuild Free Set") \
f(init_evac, " Initial Evacuation") \
SHENANDOAH_GC_PAR_PHASE_DO(evac_, " E: ", f) \
SHENANDOAH_PAR_PHASE_DO(evac_, " E: ", f) \
\
f(conc_weak_roots, "Concurrent Weak Roots") \
f(conc_cleanup_early, "Concurrent Cleanup") \
@ -106,7 +106,7 @@ class outputStream;
f(final_update_refs, "Pause Final Update Refs (N)") \
f(final_update_refs_finish_work, " Finish Work") \
f(final_update_refs_roots, " Update Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(final_update_, " UR: ", f) \
SHENANDOAH_PAR_PHASE_DO(final_update_, " UR: ", f) \
f(final_update_refs_update_region_states, " Update Region States") \
f(final_update_refs_trash_cset, " Trash Collection Set") \
f(final_update_refs_rebuild_freeset, " Rebuild Free Set") \
@ -116,32 +116,32 @@ class outputStream;
f(degen_gc_gross, "Pause Degenerated GC (G)") \
f(degen_gc, "Pause Degenerated GC (N)") \
f(degen_gc_update_roots, " Degen Update Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(degen_gc_update_, " DU: ", f) \
SHENANDOAH_PAR_PHASE_DO(degen_gc_update_, " DU: ", f) \
\
f(full_gc_gross, "Pause Full GC (G)") \
f(full_gc, "Pause Full GC (N)") \
f(full_gc_heapdump_pre, " Pre Heap Dump") \
f(full_gc_prepare, " Prepare") \
f(full_gc_scan_roots, " Scan Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_scan_roots_, " FS: ", f) \
SHENANDOAH_PAR_PHASE_DO(full_gc_scan_roots_, " FS: ", f) \
f(full_gc_update_roots, " Update Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_update_roots_, " FU: ", f) \
SHENANDOAH_PAR_PHASE_DO(full_gc_update_roots_, " FU: ", f) \
f(full_gc_mark, " Mark") \
f(full_gc_mark_finish_queues, " Finish Queues") \
f(full_gc_weakrefs, " Weak References") \
f(full_gc_weakrefs_process, " Process") \
f(full_gc_purge, " System Purge") \
f(full_gc_purge_class_unload, " Unload Classes") \
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_purge_cu_par_, " CU: ", f) \
SHENANDOAH_PAR_PHASE_DO(full_gc_purge_cu_par_, " CU: ", f) \
f(full_gc_purge_weak_par, " Weak Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_purge_weak_p_, " WR: ", f) \
SHENANDOAH_PAR_PHASE_DO(full_gc_purge_weak_p_, " WR: ", f) \
f(full_gc_purge_cldg, " CLDG") \
f(full_gc_calculate_addresses, " Calculate Addresses") \
f(full_gc_calculate_addresses_regular, " Regular Objects") \
f(full_gc_calculate_addresses_humong, " Humongous Objects") \
f(full_gc_adjust_pointers, " Adjust Pointers") \
f(full_gc_adjust_roots, " Adjust Roots") \
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_adjust_roots_, " FA: ", f) \
SHENANDOAH_PAR_PHASE_DO(full_gc_adjust_roots_, " FA: ", f) \
f(full_gc_copy_objects, " Copy Objects") \
f(full_gc_copy_objects_regular, " Regular Objects") \
f(full_gc_copy_objects_humong, " Humongous Objects") \
@ -153,7 +153,7 @@ class outputStream;
f(conc_uncommit, "Concurrent Uncommit") \
\
f(heap_iteration_roots, "Heap Iteration") \
SHENANDOAH_GC_PAR_PHASE_DO(heap_iteration_roots_, " HI: ", f) \
SHENANDOAH_PAR_PHASE_DO(heap_iteration_roots_, " HI: ", f) \
// end
typedef WorkerDataArray<double> ShenandoahWorkerData;
@ -162,20 +162,20 @@ class ShenandoahPhaseTimings : public CHeapObj<mtGC> {
friend class ShenandoahGCPhase;
friend class ShenandoahWorkerTimingsTracker;
public:
#define GC_PHASE_DECLARE_ENUM(type, title) type,
#define SHENANDOAH_PHASE_DECLARE_ENUM(type, title) type,
enum Phase {
SHENANDOAH_GC_PHASE_DO(GC_PHASE_DECLARE_ENUM)
SHENANDOAH_PHASE_DO(SHENANDOAH_PHASE_DECLARE_ENUM)
_num_phases,
_invalid_phase = _num_phases
};
enum GCParPhases {
SHENANDOAH_GC_PAR_PHASE_DO(,, GC_PHASE_DECLARE_ENUM)
GCParPhasesSentinel
enum ParPhase {
SHENANDOAH_PAR_PHASE_DO(,, SHENANDOAH_PHASE_DECLARE_ENUM)
_num_par_phases
};
#undef GC_PHASE_DECLARE_ENUM
#undef SHENANDOAH_PHASE_DECLARE_ENUM
private:
uint _max_workers;
@ -190,8 +190,8 @@ private:
static bool is_worker_phase(Phase phase);
Phase current_worker_phase() { return _current_worker_phase; }
ShenandoahWorkerData* worker_data(Phase phase, GCParPhases par_phase);
Phase worker_par_phase(Phase phase, GCParPhases par_phase);
ShenandoahWorkerData* worker_data(Phase phase, ParPhase par_phase);
Phase worker_par_phase(Phase phase, ParPhase par_phase);
void set_cycle_data(Phase phase, double time);
@ -217,15 +217,15 @@ public:
class ShenandoahWorkerTimingsTracker : public StackObj {
private:
ShenandoahPhaseTimings* const _timings;
ShenandoahPhaseTimings::Phase const _phase;
ShenandoahPhaseTimings::GCParPhases const _par_phase;
ShenandoahPhaseTimings* const _timings;
ShenandoahPhaseTimings::Phase const _phase;
ShenandoahPhaseTimings::ParPhase const _par_phase;
uint const _worker_id;
double _start_time;
EventGCPhaseParallel _event;
public:
ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::GCParPhases par_phase, uint worker_id);
ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id);
~ShenandoahWorkerTimingsTracker();
};

12
src/hotspot/share/gc/shenandoah/shenandoahRootProcessor.cpp

@ -42,13 +42,13 @@
#include "runtime/thread.hpp"
#include "services/management.hpp"
ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do, ShenandoahPhaseTimings::GCParPhases phase) :
_oops_do(oops_do), _phase(phase) {
ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase) :
_oops_do(oops_do), _par_phase(par_phase) {
}
void ShenandoahSerialRoot::oops_do(OopClosure* cl, uint worker_id) {
if (_claimed.try_set()) {
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
_oops_do(cl);
}
}
@ -74,13 +74,13 @@ void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
_jvmti_root.oops_do(cl, worker_id);
}
ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do, ShenandoahPhaseTimings::GCParPhases phase) :
_weak_oops_do(weak_oops_do), _phase(phase) {
ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do, ShenandoahPhaseTimings::ParPhase par_phase) :
_weak_oops_do(weak_oops_do), _par_phase(par_phase) {
}
void ShenandoahWeakSerialRoot::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
if (_claimed.try_set()) {
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
_weak_oops_do(is_alive, keep_alive);
}
}

26
src/hotspot/share/gc/shenandoah/shenandoahRootProcessor.hpp

@ -38,12 +38,12 @@ class ShenandoahSerialRoot {
public:
typedef void (*OopsDo)(OopClosure*);
private:
ShenandoahSharedFlag _claimed;
const OopsDo _oops_do;
const ShenandoahPhaseTimings::GCParPhases _phase;
ShenandoahSharedFlag _claimed;
const OopsDo _oops_do;
const ShenandoahPhaseTimings::ParPhase _par_phase;
public:
ShenandoahSerialRoot(OopsDo oops_do, ShenandoahPhaseTimings::GCParPhases);
ShenandoahSerialRoot(OopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase);
void oops_do(OopClosure* cl, uint worker_id);
};
@ -62,12 +62,12 @@ public:
class ShenandoahWeakSerialRoot {
typedef void (*WeakOopsDo)(BoolObjectClosure*, OopClosure*);
private:
ShenandoahSharedFlag _claimed;
const WeakOopsDo _weak_oops_do;
const ShenandoahPhaseTimings::GCParPhases _phase;
ShenandoahSharedFlag _claimed;
const WeakOopsDo _weak_oops_do;
const ShenandoahPhaseTimings::ParPhase _par_phase;
public:
ShenandoahWeakSerialRoot(WeakOopsDo oops_do, ShenandoahPhaseTimings::GCParPhases);
ShenandoahWeakSerialRoot(WeakOopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase);
void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id);
};
@ -98,9 +98,9 @@ template <bool CONCURRENT>
class ShenandoahVMRoot {
private:
OopStorage::ParState<CONCURRENT, false /* is_const */> _itr;
const ShenandoahPhaseTimings::GCParPhases _phase;
const ShenandoahPhaseTimings::ParPhase _par_phase;
public:
ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase);
ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
template <typename Closure>
void oops_do(Closure* cl, uint worker_id);
@ -109,17 +109,17 @@ public:
template <bool CONCURRENT>
class ShenandoahWeakRoot : public ShenandoahVMRoot<CONCURRENT> {
public:
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase);
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
};
template <>
class ShenandoahWeakRoot<false /*concurrent*/> {
private:
OopStorage::ParState<false /*concurrent*/, false /*is_const*/> _itr;
const ShenandoahPhaseTimings::GCParPhases _phase;
const ShenandoahPhaseTimings::ParPhase _par_phase;
public:
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase);
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
template <typename IsAliveClosure, typename KeepAliveClosure>
void weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id);

16
src/hotspot/share/gc/shenandoah/shenandoahRootProcessor.inline.hpp

@ -40,8 +40,8 @@
#include "runtime/safepoint.hpp"
template <bool CONCURRENT>
inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
_itr(storage), _phase(phase) {
inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
_itr(storage), _par_phase(par_phase) {
}
template <bool CONCURRENT>
@ -50,23 +50,23 @@ inline void ShenandoahVMRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
if (CONCURRENT) {
_itr.oops_do(cl);
} else {
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
_itr.oops_do(cl);
}
}
template <bool CONCURRENT>
inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
ShenandoahVMRoot<CONCURRENT>(storage, phase) {
inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
ShenandoahVMRoot<CONCURRENT>(storage, par_phase) {
}
inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
_itr(storage), _phase(phase) {
inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
_itr(storage), _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(_phase, worker_id);
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
_itr.weak_oops_do(is_alive, keep_alive);
}