8196341: Add JFR events for parallel phases of G1
3152 void G1CollectedHeap::restore_after_evac_failure() {
3153 double remove_self_forwards_start = os::elapsedTime();
3154
3155 remove_self_forwarding_pointers();
3156 SharedRestorePreservedMarksTaskExecutor task_executor(workers());
3157 _preserved_marks_set.restore(&task_executor);
3158
3159 g1_policy()->phase_times()->record_evac_fail_remove_self_forwards((os::elapsedTime() - remove_self_forwards_start) * 1000
3160 }
3161
3162 void G1CollectedHeap::preserve_mark_during_evac_failure(uint worker_id, oop obj, markOop m) {
3163 if (!_evacuation_failed) {
3164 _evacuation_failed = true;
3165 }
3166
3167 _evacuation_failed_info_array[worker_id].register_copy_failure(obj->size());
3168 _preserved_marks_set.get(worker_id)->push_if_necessary(obj, m);
3169 }
3170
3171 bool G1ParEvacuateFollowersClosure::offer_termination() {
3172 G1ParScanThreadState* const pss = par_scan_state();
3173 start_term_time();
3174 const bool res = terminator()->offer_termination();
3175 end_term_time();
3176 return res;
3177 }
3178
3179 void G1ParEvacuateFollowersClosure::do_void() {
3180 G1ParScanThreadState* const pss = par_scan_state();
3181 pss->trim_queue();
3182 do {
3183 pss->steal_and_trim_queue(queues());
3184 } while (!offer_termination());
3185 }
3186
3187 class G1ParTask : public AbstractGangTask {
3188 protected:
3189 G1CollectedHeap* _g1h;
3190 G1ParScanThreadStateSet* _pss;
3191 RefToScanQueueSet* _queues;
3192 G1RootProcessor* _root_processor;
3193 ParallelTaskTerminator _terminator;
3194 uint _n_workers;
3195
3196 public:
3197 G1ParTask(G1CollectedHeap* g1h, G1ParScanThreadStateSet* per_thread_states, RefToScanQueueSet *task_queues, G1RootProcess
3198 : AbstractGangTask("G1 collection"),
3199 _g1h(g1h),
3200 _pss(per_thread_states),
3201 _queues(task_queues),
3202 _root_processor(root_processor),
|
3152 void G1CollectedHeap::restore_after_evac_failure() {
3153 double remove_self_forwards_start = os::elapsedTime();
3154
3155 remove_self_forwarding_pointers();
3156 SharedRestorePreservedMarksTaskExecutor task_executor(workers());
3157 _preserved_marks_set.restore(&task_executor);
3158
3159 g1_policy()->phase_times()->record_evac_fail_remove_self_forwards((os::elapsedTime() - remove_self_forwards_start) * 1000
3160 }
3161
3162 void G1CollectedHeap::preserve_mark_during_evac_failure(uint worker_id, oop obj, markOop m) {
3163 if (!_evacuation_failed) {
3164 _evacuation_failed = true;
3165 }
3166
3167 _evacuation_failed_info_array[worker_id].register_copy_failure(obj->size());
3168 _preserved_marks_set.get(worker_id)->push_if_necessary(obj, m);
3169 }
3170
3171 bool G1ParEvacuateFollowersClosure::offer_termination() {
3172 EventGCPhaseParallel event;
3173 G1ParScanThreadState* const pss = par_scan_state();
3174 start_term_time();
3175 const bool res = terminator()->offer_termination();
3176 end_term_time();
3177 event.commit(GCId::current(), pss->worker_id(), G1GCPhaseTimes::phase_name(G1GCPhaseTimes::Termination));
3178 return res;
3179 }
3180
3181 void G1ParEvacuateFollowersClosure::do_void() {
3182 EventGCPhaseParallel event;
3183 G1ParScanThreadState* const pss = par_scan_state();
3184 pss->trim_queue();
3185 event.commit(GCId::current(), pss->worker_id(), G1GCPhaseTimes::phase_name(G1GCPhaseTimes::ObjCopy));
3186 do {
3187 EventGCPhaseParallel event;
3188 pss->steal_and_trim_queue(queues());
3189 event.commit(GCId::current(), pss->worker_id(), G1GCPhaseTimes::phase_name(G1GCPhaseTimes::ObjCopy));
3190 } while (!offer_termination());
3191 }
3192
3193 class G1ParTask : public AbstractGangTask {
3194 protected:
3195 G1CollectedHeap* _g1h;
3196 G1ParScanThreadStateSet* _pss;
3197 RefToScanQueueSet* _queues;
3198 G1RootProcessor* _root_processor;
3199 ParallelTaskTerminator _terminator;
3200 uint _n_workers;
3201
3202 public:
3203 G1ParTask(G1CollectedHeap* g1h, G1ParScanThreadStateSet* per_thread_states, RefToScanQueueSet *task_queues, G1RootProcess
3204 : AbstractGangTask("G1 collection"),
3205 _g1h(g1h),
3206 _pss(per_thread_states),
3207 _queues(task_queues),
3208 _root_processor(root_processor),
|
4033 double serial_time = os::elapsedTime();
4034 do_serial_work();
4035 timer->record_serial_free_cset_time_ms((os::elapsedTime() - serial_time) * 1000.0);
4036 }
4037 }
4038
4039 // Start parallel work.
4040 double young_time = 0.0;
4041 bool has_young_time = false;
4042 double non_young_time = 0.0;
4043 bool has_non_young_time = false;
4044
4045 while (true) {
4046 size_t end = Atomic::add(chunk_size(), &_parallel_work_claim);
4047 size_t cur = end - chunk_size();
4048
4049 if (cur >= _num_work_items) {
4050 break;
4051 }
4052
4053 double start_time = os::elapsedTime();
4054
4055 end = MIN2(end, _num_work_items);
4056
4057 for (; cur < end; cur++) {
4058 bool is_young = _work_items[cur].is_young;
4059
4060 do_parallel_work_for_region(_work_items[cur].region_idx, is_young, _work_items[cur].evacuation_failed);
4061
4062 double end_time = os::elapsedTime();
4063 double time_taken = end_time - start_time;
4064 if (is_young) {
4065 young_time += time_taken;
4066 has_young_time = true;
4067 } else {
4068 non_young_time += time_taken;
4069 has_non_young_time = true;
4070 }
4071 start_time = end_time;
4072 }
4073 }
4074
4075 if (has_young_time) {
4076 timer->record_time_secs(G1GCPhaseTimes::YoungFreeCSet, worker_id, young_time);
4077 }
4078 if (has_non_young_time) {
4079 timer->record_time_secs(G1GCPhaseTimes::NonYoungFreeCSet, worker_id, non_young_time);
4080 }
4081 }
4082 };
4083
4084 void G1CollectedHeap::free_collection_set(G1CollectionSet* collection_set, EvacuationInfo& evacuation_info, const size_t* s
4085 _eden.clear();
4086
4087 double free_cset_start_time = os::elapsedTime();
4088
|
4039 double serial_time = os::elapsedTime();
4040 do_serial_work();
4041 timer->record_serial_free_cset_time_ms((os::elapsedTime() - serial_time) * 1000.0);
4042 }
4043 }
4044
4045 // Start parallel work.
4046 double young_time = 0.0;
4047 bool has_young_time = false;
4048 double non_young_time = 0.0;
4049 bool has_non_young_time = false;
4050
4051 while (true) {
4052 size_t end = Atomic::add(chunk_size(), &_parallel_work_claim);
4053 size_t cur = end - chunk_size();
4054
4055 if (cur >= _num_work_items) {
4056 break;
4057 }
4058
4059 EventGCPhaseParallel event;
4060 double start_time = os::elapsedTime();
4061
4062 end = MIN2(end, _num_work_items);
4063
4064 for (; cur < end; cur++) {
4065 bool is_young = _work_items[cur].is_young;
4066
4067 do_parallel_work_for_region(_work_items[cur].region_idx, is_young, _work_items[cur].evacuation_failed);
4068
4069 double end_time = os::elapsedTime();
4070 double time_taken = end_time - start_time;
4071 if (is_young) {
4072 young_time += time_taken;
4073 has_young_time = true;
4074 event.commit(GCId::current(), worker_id, G1GCPhaseTimes::phase_name(G1GCPhaseTimes::YoungFreeCSet));
4075 } else {
4076 non_young_time += time_taken;
4077 has_non_young_time = true;
4078 event.commit(GCId::current(), worker_id, G1GCPhaseTimes::phase_name(G1GCPhaseTimes::NonYoungFreeCSet));
4079 }
4080 start_time = end_time;
4081 }
4082 }
4083
4084 if (has_young_time) {
4085 timer->record_time_secs(G1GCPhaseTimes::YoungFreeCSet, worker_id, young_time);
4086 }
4087 if (has_non_young_time) {
4088 timer->record_time_secs(G1GCPhaseTimes::NonYoungFreeCSet, worker_id, non_young_time);
4089 }
4090 }
4091 };
4092
4093 void G1CollectedHeap::free_collection_set(G1CollectionSet* collection_set, EvacuationInfo& evacuation_info, const size_t* s
4094 _eden.clear();
4095
4096 double free_cset_start_time = os::elapsedTime();
4097
|