Skip to content

Commit 05b3bc5

Browse files
shipilevshipilev
committedApr 30, 2020
8243573: Shenandoah: rename GCParPhases and related code
Reviewed-by: rkennke
·
JEP-429-branchpoint
1 parent e513aca commit 05b3bc5

5 files changed

+66
-66
lines changed
 

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

+12-12
Original file line numberDiff line numberDiff line change
@@ -38,14 +38,14 @@
3838
#define SHENANDOAH_US_TIME_FORMAT "%8.0lf"
3939
#define SHENANDOAH_US_WORKER_TIME_FORMAT "%3.0lf"
4040

41-
#define GC_PHASE_DECLARE_NAME(type, title) \
41+
#define SHENANDOAH_PHASE_DECLARE_NAME(type, title) \
4242
title,
4343

4444
const char* ShenandoahPhaseTimings::_phase_names[] = {
45-
SHENANDOAH_GC_PHASE_DO(GC_PHASE_DECLARE_NAME)
45+
SHENANDOAH_PHASE_DO(SHENANDOAH_PHASE_DECLARE_NAME)
4646
};
4747

48-
#undef GC_PHASE_DECLARE_NAME
48+
#undef SHENANDOAH_PHASE_DECLARE_NAME
4949

5050
ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
5151
_max_workers(max_workers) {
@@ -55,7 +55,7 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
5555
for (uint i = 0; i < _num_phases; i++) {
5656
#define SHENANDOAH_WORKER_DATA_NULL(type, title) \
5757
_worker_data[i] = NULL;
58-
SHENANDOAH_GC_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_NULL)
58+
SHENANDOAH_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_NULL)
5959
#undef SHENANDOAH_WORKER_DATA_NULL
6060
_cycle_data[i] = 0;
6161
}
@@ -68,7 +68,7 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
6868
int c = 0;
6969
#define SHENANDOAH_WORKER_DATA_INIT(type, title) \
7070
if (c++ != 0) _worker_data[i + c] = new ShenandoahWorkerData(title, _max_workers);
71-
SHENANDOAH_GC_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_INIT)
71+
SHENANDOAH_PAR_PHASE_DO(,, SHENANDOAH_WORKER_DATA_INIT)
7272
#undef SHENANDOAH_WORKER_DATA_INIT
7373
}
7474
}
@@ -79,14 +79,14 @@ ShenandoahPhaseTimings::ShenandoahPhaseTimings(uint max_workers) :
7979
_current_worker_phase = _invalid_phase;
8080
}
8181

82-
ShenandoahPhaseTimings::Phase ShenandoahPhaseTimings::worker_par_phase(Phase phase, GCParPhases par_phase) {
82+
ShenandoahPhaseTimings::Phase ShenandoahPhaseTimings::worker_par_phase(Phase phase, ParPhase par_phase) {
8383
assert(is_worker_phase(phase), "Phase should accept worker phase times: %s", phase_name(phase));
8484
Phase p = Phase(phase + 1 + par_phase);
8585
assert(p >= 0 && p < _num_phases, "Out of bound for: %s", phase_name(phase));
8686
return p;
8787
}
8888

89-
ShenandoahWorkerData* ShenandoahPhaseTimings::worker_data(Phase phase, GCParPhases par_phase) {
89+
ShenandoahWorkerData* ShenandoahPhaseTimings::worker_data(Phase phase, ParPhase par_phase) {
9090
Phase p = worker_par_phase(phase, par_phase);
9191
ShenandoahWorkerData* wd = _worker_data[p];
9292
assert(wd != NULL, "Counter initialized: %s", phase_name(p));
@@ -136,8 +136,8 @@ void ShenandoahPhaseTimings::record_workers_start(Phase phase) {
136136
phase_name(phase), phase_name(_current_worker_phase));
137137
_current_worker_phase = phase;
138138

139-
for (uint i = 1; i < GCParPhasesSentinel; i++) {
140-
worker_data(phase, GCParPhases(i))->reset();
139+
for (uint i = 1; i < _num_par_phases; i++) {
140+
worker_data(phase, ParPhase(i))->reset();
141141
}
142142
}
143143

@@ -151,8 +151,8 @@ void ShenandoahPhaseTimings::flush_par_workers_to_cycle() {
151151
Phase phase = Phase(pi);
152152
if (is_worker_phase(phase)) {
153153
double s = 0;
154-
for (uint i = 1; i < GCParPhasesSentinel; i++) {
155-
double t = worker_data(phase, GCParPhases(i))->sum();
154+
for (uint i = 1; i < _num_par_phases; i++) {
155+
double t = worker_data(phase, ParPhase(i))->sum();
156156
// add to each line in phase
157157
set_cycle_data(Phase(phase + i + 1), t);
158158
s += t;
@@ -233,7 +233,7 @@ void ShenandoahPhaseTimings::print_global_on(outputStream* out) const {
233233
}
234234
}
235235

236-
ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::GCParPhases par_phase, uint worker_id) :
236+
ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id) :
237237
_timings(ShenandoahHeap::heap()->phase_timings()), _phase(_timings->current_worker_phase()),
238238
_par_phase(par_phase), _worker_id(worker_id) {
239239
assert(_timings->worker_data(_phase, _par_phase)->get(_worker_id) == ShenandoahWorkerData::uninitialized(),

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

+27-27
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@
3333
class ShenandoahCollectorPolicy;
3434
class outputStream;
3535

36-
#define SHENANDOAH_GC_PAR_PHASE_DO(CNT_PREFIX, DESC_PREFIX, f) \
36+
#define SHENANDOAH_PAR_PHASE_DO(CNT_PREFIX, DESC_PREFIX, f) \
3737
f(CNT_PREFIX ## TotalWork, DESC_PREFIX "<total>") \
3838
f(CNT_PREFIX ## ThreadRoots, DESC_PREFIX "Thread Roots") \
3939
f(CNT_PREFIX ## CodeCacheRoots, DESC_PREFIX "Code Cache Roots") \
@@ -56,15 +56,15 @@ class outputStream;
5656
f(CNT_PREFIX ## FinishQueues, DESC_PREFIX "Finish Queues") \
5757
// end
5858

59-
#define SHENANDOAH_GC_PHASE_DO(f) \
59+
#define SHENANDOAH_PHASE_DO(f) \
6060
f(conc_reset, "Concurrent Reset") \
6161
\
6262
f(init_mark_gross, "Pause Init Mark (G)") \
6363
f(init_mark, "Pause Init Mark (N)") \
6464
f(make_parsable, " Make Parsable") \
6565
f(init_update_region_states, " Update Region States") \
6666
f(scan_roots, " Scan Roots") \
67-
SHENANDOAH_GC_PAR_PHASE_DO(scan_, " S: ", f) \
67+
SHENANDOAH_PAR_PHASE_DO(scan_, " S: ", f) \
6868
f(resize_tlabs, " Resize TLABs") \
6969
\
7070
f(conc_mark, "Concurrent Marking") \
@@ -73,22 +73,22 @@ class outputStream;
7373
f(final_mark_gross, "Pause Final Mark (G)") \
7474
f(final_mark, "Pause Final Mark (N)") \
7575
f(update_roots, " Update Roots") \
76-
SHENANDOAH_GC_PAR_PHASE_DO(update_, " U: ", f) \
76+
SHENANDOAH_PAR_PHASE_DO(update_, " U: ", f) \
7777
f(finish_queues, " Finish Queues") \
7878
f(weakrefs, " Weak References") \
7979
f(weakrefs_process, " Process") \
8080
f(purge, " System Purge") \
8181
f(purge_class_unload, " Unload Classes") \
82-
SHENANDOAH_GC_PAR_PHASE_DO(purge_cu_par_, " CU: ", f) \
82+
SHENANDOAH_PAR_PHASE_DO(purge_cu_par_, " CU: ", f) \
8383
f(purge_weak_par, " Weak Roots") \
84-
SHENANDOAH_GC_PAR_PHASE_DO(purge_weak_par_, " WR: ", f) \
84+
SHENANDOAH_PAR_PHASE_DO(purge_weak_par_, " WR: ", f) \
8585
f(purge_cldg, " CLDG") \
8686
f(final_update_region_states, " Update Region States") \
8787
f(retire_tlabs, " Retire TLABs") \
8888
f(choose_cset, " Choose Collection Set") \
8989
f(final_rebuild_freeset, " Rebuild Free Set") \
9090
f(init_evac, " Initial Evacuation") \
91-
SHENANDOAH_GC_PAR_PHASE_DO(evac_, " E: ", f) \
91+
SHENANDOAH_PAR_PHASE_DO(evac_, " E: ", f) \
9292
\
9393
f(conc_weak_roots, "Concurrent Weak Roots") \
9494
f(conc_cleanup_early, "Concurrent Cleanup") \
@@ -106,7 +106,7 @@ class outputStream;
106106
f(final_update_refs, "Pause Final Update Refs (N)") \
107107
f(final_update_refs_finish_work, " Finish Work") \
108108
f(final_update_refs_roots, " Update Roots") \
109-
SHENANDOAH_GC_PAR_PHASE_DO(final_update_, " UR: ", f) \
109+
SHENANDOAH_PAR_PHASE_DO(final_update_, " UR: ", f) \
110110
f(final_update_refs_update_region_states, " Update Region States") \
111111
f(final_update_refs_trash_cset, " Trash Collection Set") \
112112
f(final_update_refs_rebuild_freeset, " Rebuild Free Set") \
@@ -116,32 +116,32 @@ class outputStream;
116116
f(degen_gc_gross, "Pause Degenerated GC (G)") \
117117
f(degen_gc, "Pause Degenerated GC (N)") \
118118
f(degen_gc_update_roots, " Degen Update Roots") \
119-
SHENANDOAH_GC_PAR_PHASE_DO(degen_gc_update_, " DU: ", f) \
119+
SHENANDOAH_PAR_PHASE_DO(degen_gc_update_, " DU: ", f) \
120120
\
121121
f(full_gc_gross, "Pause Full GC (G)") \
122122
f(full_gc, "Pause Full GC (N)") \
123123
f(full_gc_heapdump_pre, " Pre Heap Dump") \
124124
f(full_gc_prepare, " Prepare") \
125125
f(full_gc_scan_roots, " Scan Roots") \
126-
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_scan_roots_, " FS: ", f) \
126+
SHENANDOAH_PAR_PHASE_DO(full_gc_scan_roots_, " FS: ", f) \
127127
f(full_gc_update_roots, " Update Roots") \
128-
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_update_roots_, " FU: ", f) \
128+
SHENANDOAH_PAR_PHASE_DO(full_gc_update_roots_, " FU: ", f) \
129129
f(full_gc_mark, " Mark") \
130130
f(full_gc_mark_finish_queues, " Finish Queues") \
131131
f(full_gc_weakrefs, " Weak References") \
132132
f(full_gc_weakrefs_process, " Process") \
133133
f(full_gc_purge, " System Purge") \
134134
f(full_gc_purge_class_unload, " Unload Classes") \
135-
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_purge_cu_par_, " CU: ", f) \
135+
SHENANDOAH_PAR_PHASE_DO(full_gc_purge_cu_par_, " CU: ", f) \
136136
f(full_gc_purge_weak_par, " Weak Roots") \
137-
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_purge_weak_p_, " WR: ", f) \
137+
SHENANDOAH_PAR_PHASE_DO(full_gc_purge_weak_p_, " WR: ", f) \
138138
f(full_gc_purge_cldg, " CLDG") \
139139
f(full_gc_calculate_addresses, " Calculate Addresses") \
140140
f(full_gc_calculate_addresses_regular, " Regular Objects") \
141141
f(full_gc_calculate_addresses_humong, " Humongous Objects") \
142142
f(full_gc_adjust_pointers, " Adjust Pointers") \
143143
f(full_gc_adjust_roots, " Adjust Roots") \
144-
SHENANDOAH_GC_PAR_PHASE_DO(full_gc_adjust_roots_, " FA: ", f) \
144+
SHENANDOAH_PAR_PHASE_DO(full_gc_adjust_roots_, " FA: ", f) \
145145
f(full_gc_copy_objects, " Copy Objects") \
146146
f(full_gc_copy_objects_regular, " Regular Objects") \
147147
f(full_gc_copy_objects_humong, " Humongous Objects") \
@@ -153,7 +153,7 @@ class outputStream;
153153
f(conc_uncommit, "Concurrent Uncommit") \
154154
\
155155
f(heap_iteration_roots, "Heap Iteration") \
156-
SHENANDOAH_GC_PAR_PHASE_DO(heap_iteration_roots_, " HI: ", f) \
156+
SHENANDOAH_PAR_PHASE_DO(heap_iteration_roots_, " HI: ", f) \
157157
// end
158158

159159
typedef WorkerDataArray<double> ShenandoahWorkerData;
@@ -162,20 +162,20 @@ class ShenandoahPhaseTimings : public CHeapObj<mtGC> {
162162
friend class ShenandoahGCPhase;
163163
friend class ShenandoahWorkerTimingsTracker;
164164
public:
165-
#define GC_PHASE_DECLARE_ENUM(type, title) type,
165+
#define SHENANDOAH_PHASE_DECLARE_ENUM(type, title) type,
166166

167167
enum Phase {
168-
SHENANDOAH_GC_PHASE_DO(GC_PHASE_DECLARE_ENUM)
168+
SHENANDOAH_PHASE_DO(SHENANDOAH_PHASE_DECLARE_ENUM)
169169
_num_phases,
170170
_invalid_phase = _num_phases
171171
};
172172

173-
enum GCParPhases {
174-
SHENANDOAH_GC_PAR_PHASE_DO(,, GC_PHASE_DECLARE_ENUM)
175-
GCParPhasesSentinel
173+
enum ParPhase {
174+
SHENANDOAH_PAR_PHASE_DO(,, SHENANDOAH_PHASE_DECLARE_ENUM)
175+
_num_par_phases
176176
};
177177

178-
#undef GC_PHASE_DECLARE_ENUM
178+
#undef SHENANDOAH_PHASE_DECLARE_ENUM
179179

180180
private:
181181
uint _max_workers;
@@ -190,8 +190,8 @@ class ShenandoahPhaseTimings : public CHeapObj<mtGC> {
190190
static bool is_worker_phase(Phase phase);
191191
Phase current_worker_phase() { return _current_worker_phase; }
192192

193-
ShenandoahWorkerData* worker_data(Phase phase, GCParPhases par_phase);
194-
Phase worker_par_phase(Phase phase, GCParPhases par_phase);
193+
ShenandoahWorkerData* worker_data(Phase phase, ParPhase par_phase);
194+
Phase worker_par_phase(Phase phase, ParPhase par_phase);
195195

196196
void set_cycle_data(Phase phase, double time);
197197

@@ -217,15 +217,15 @@ class ShenandoahPhaseTimings : public CHeapObj<mtGC> {
217217

218218
class ShenandoahWorkerTimingsTracker : public StackObj {
219219
private:
220-
ShenandoahPhaseTimings* const _timings;
221-
ShenandoahPhaseTimings::Phase const _phase;
222-
ShenandoahPhaseTimings::GCParPhases const _par_phase;
220+
ShenandoahPhaseTimings* const _timings;
221+
ShenandoahPhaseTimings::Phase const _phase;
222+
ShenandoahPhaseTimings::ParPhase const _par_phase;
223223
uint const _worker_id;
224224

225225
double _start_time;
226226
EventGCPhaseParallel _event;
227227
public:
228-
ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::GCParPhases par_phase, uint worker_id);
228+
ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id);
229229
~ShenandoahWorkerTimingsTracker();
230230
};
231231

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

+6-6
Original file line numberDiff line numberDiff line change
@@ -42,13 +42,13 @@
4242
#include "runtime/thread.hpp"
4343
#include "services/management.hpp"
4444

45-
ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do, ShenandoahPhaseTimings::GCParPhases phase) :
46-
_oops_do(oops_do), _phase(phase) {
45+
ShenandoahSerialRoot::ShenandoahSerialRoot(ShenandoahSerialRoot::OopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase) :
46+
_oops_do(oops_do), _par_phase(par_phase) {
4747
}
4848

4949
void ShenandoahSerialRoot::oops_do(OopClosure* cl, uint worker_id) {
5050
if (_claimed.try_set()) {
51-
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
51+
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
5252
_oops_do(cl);
5353
}
5454
}
@@ -74,13 +74,13 @@ void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
7474
_jvmti_root.oops_do(cl, worker_id);
7575
}
7676

77-
ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do, ShenandoahPhaseTimings::GCParPhases phase) :
78-
_weak_oops_do(weak_oops_do), _phase(phase) {
77+
ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do, ShenandoahPhaseTimings::ParPhase par_phase) :
78+
_weak_oops_do(weak_oops_do), _par_phase(par_phase) {
7979
}
8080

8181
void ShenandoahWeakSerialRoot::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
8282
if (_claimed.try_set()) {
83-
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
83+
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
8484
_weak_oops_do(is_alive, keep_alive);
8585
}
8686
}

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

+13-13
Original file line numberDiff line numberDiff line change
@@ -38,12 +38,12 @@ class ShenandoahSerialRoot {
3838
public:
3939
typedef void (*OopsDo)(OopClosure*);
4040
private:
41-
ShenandoahSharedFlag _claimed;
42-
const OopsDo _oops_do;
43-
const ShenandoahPhaseTimings::GCParPhases _phase;
41+
ShenandoahSharedFlag _claimed;
42+
const OopsDo _oops_do;
43+
const ShenandoahPhaseTimings::ParPhase _par_phase;
4444

4545
public:
46-
ShenandoahSerialRoot(OopsDo oops_do, ShenandoahPhaseTimings::GCParPhases);
46+
ShenandoahSerialRoot(OopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase);
4747
void oops_do(OopClosure* cl, uint worker_id);
4848
};
4949

@@ -62,12 +62,12 @@ class ShenandoahSerialRoots {
6262
class ShenandoahWeakSerialRoot {
6363
typedef void (*WeakOopsDo)(BoolObjectClosure*, OopClosure*);
6464
private:
65-
ShenandoahSharedFlag _claimed;
66-
const WeakOopsDo _weak_oops_do;
67-
const ShenandoahPhaseTimings::GCParPhases _phase;
65+
ShenandoahSharedFlag _claimed;
66+
const WeakOopsDo _weak_oops_do;
67+
const ShenandoahPhaseTimings::ParPhase _par_phase;
6868

6969
public:
70-
ShenandoahWeakSerialRoot(WeakOopsDo oops_do, ShenandoahPhaseTimings::GCParPhases);
70+
ShenandoahWeakSerialRoot(WeakOopsDo oops_do, ShenandoahPhaseTimings::ParPhase par_phase);
7171
void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id);
7272
};
7373

@@ -98,9 +98,9 @@ template <bool CONCURRENT>
9898
class ShenandoahVMRoot {
9999
private:
100100
OopStorage::ParState<CONCURRENT, false /* is_const */> _itr;
101-
const ShenandoahPhaseTimings::GCParPhases _phase;
101+
const ShenandoahPhaseTimings::ParPhase _par_phase;
102102
public:
103-
ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase);
103+
ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
104104

105105
template <typename Closure>
106106
void oops_do(Closure* cl, uint worker_id);
@@ -109,17 +109,17 @@ class ShenandoahVMRoot {
109109
template <bool CONCURRENT>
110110
class ShenandoahWeakRoot : public ShenandoahVMRoot<CONCURRENT> {
111111
public:
112-
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase);
112+
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
113113
};
114114

115115
template <>
116116
class ShenandoahWeakRoot<false /*concurrent*/> {
117117
private:
118118
OopStorage::ParState<false /*concurrent*/, false /*is_const*/> _itr;
119-
const ShenandoahPhaseTimings::GCParPhases _phase;
119+
const ShenandoahPhaseTimings::ParPhase _par_phase;
120120

121121
public:
122-
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase);
122+
ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase);
123123

124124
template <typename IsAliveClosure, typename KeepAliveClosure>
125125
void weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id);

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

+8-8
Original file line numberDiff line numberDiff line change
@@ -40,8 +40,8 @@
4040
#include "runtime/safepoint.hpp"
4141

4242
template <bool CONCURRENT>
43-
inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
44-
_itr(storage), _phase(phase) {
43+
inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
44+
_itr(storage), _par_phase(par_phase) {
4545
}
4646

4747
template <bool CONCURRENT>
@@ -50,23 +50,23 @@ inline void ShenandoahVMRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
5050
if (CONCURRENT) {
5151
_itr.oops_do(cl);
5252
} else {
53-
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
53+
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
5454
_itr.oops_do(cl);
5555
}
5656
}
5757

5858
template <bool CONCURRENT>
59-
inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
60-
ShenandoahVMRoot<CONCURRENT>(storage, phase) {
59+
inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
60+
ShenandoahVMRoot<CONCURRENT>(storage, par_phase) {
6161
}
6262

63-
inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
64-
_itr(storage), _phase(phase) {
63+
inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::ParPhase par_phase) :
64+
_itr(storage), _par_phase(par_phase) {
6565
}
6666

6767
template <typename IsAliveClosure, typename KeepAliveClosure>
6868
void ShenandoahWeakRoot<false /* concurrent */>::weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id) {
69-
ShenandoahWorkerTimingsTracker timer(_phase, worker_id);
69+
ShenandoahWorkerTimingsTracker timer(_par_phase, worker_id);
7070
_itr.weak_oops_do(is_alive, keep_alive);
7171
}
7272

0 commit comments

Comments
 (0)
Please sign in to comment.