src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp

Print this page
rev 4802 : imported patch optimize-nmethod-scanning


 102     for (uint i = 0; i < _length; ++i) {
 103       _sum += _data[i];
 104     }
 105     _average = (double)_sum / (double)_length;
 106     _has_new_data = false;
 107   }
 108 };
 109 
 110 class G1GCPhaseTimes : public CHeapObj<mtGC> {
 111 
 112  private:
 113   uint _active_gc_threads;
 114   uint _max_gc_threads;
 115 
 116   WorkerDataArray<double> _last_gc_worker_start_times_ms;
 117   WorkerDataArray<double> _last_ext_root_scan_times_ms;
 118   WorkerDataArray<double> _last_satb_filtering_times_ms;
 119   WorkerDataArray<double> _last_update_rs_times_ms;
 120   WorkerDataArray<int>    _last_update_rs_processed_buffers;
 121   WorkerDataArray<double> _last_scan_rs_times_ms;


 122   WorkerDataArray<double> _last_obj_copy_times_ms;
 123   WorkerDataArray<double> _last_termination_times_ms;
 124   WorkerDataArray<size_t> _last_termination_attempts;
 125   WorkerDataArray<double> _last_gc_worker_end_times_ms;
 126   WorkerDataArray<double> _last_gc_worker_times_ms;
 127   WorkerDataArray<double> _last_gc_worker_other_times_ms;
 128 
 129   double _cur_collection_par_time_ms;
 130   double _cur_collection_code_root_fixup_time_ms;

 131 
 132   double _cur_clear_ct_time_ms;
 133   double _cur_ref_proc_time_ms;
 134   double _cur_ref_enq_time_ms;
 135 
 136   double _cur_collection_start_sec;
 137   double _root_region_scan_wait_time_ms;
 138 
 139   double _recorded_young_cset_choice_time_ms;
 140   double _recorded_non_young_cset_choice_time_ms;
 141 
 142   double _recorded_young_free_cset_time_ms;
 143   double _recorded_non_young_free_cset_time_ms;
 144 
 145   double _cur_verify_before_time_ms;
 146   double _cur_verify_after_time_ms;
 147 
 148   // Helper methods for detailed logging
 149   void print_stats(int level, const char* str, double value);
 150   void print_stats(int level, const char* str, double value, int workers);


 162   void record_ext_root_scan_time(uint worker_i, double ms) {
 163     _last_ext_root_scan_times_ms.set(worker_i, ms);
 164   }
 165 
 166   void record_satb_filtering_time(uint worker_i, double ms) {
 167     _last_satb_filtering_times_ms.set(worker_i, ms);
 168   }
 169 
 170   void record_update_rs_time(uint worker_i, double ms) {
 171     _last_update_rs_times_ms.set(worker_i, ms);
 172   }
 173 
 174   void record_update_rs_processed_buffers(uint worker_i, int processed_buffers) {
 175     _last_update_rs_processed_buffers.set(worker_i, processed_buffers);
 176   }
 177 
 178   void record_scan_rs_time(uint worker_i, double ms) {
 179     _last_scan_rs_times_ms.set(worker_i, ms);
 180   }
 181 








 182   void record_obj_copy_time(uint worker_i, double ms) {
 183     _last_obj_copy_times_ms.set(worker_i, ms);
 184   }
 185 
 186   void add_obj_copy_time(uint worker_i, double ms) {
 187     _last_obj_copy_times_ms.add(worker_i, ms);
 188   }
 189 
 190   void record_termination(uint worker_i, double ms, size_t attempts) {
 191     _last_termination_times_ms.set(worker_i, ms);
 192     _last_termination_attempts.set(worker_i, attempts);
 193   }
 194 
 195   void record_gc_worker_end_time(uint worker_i, double ms) {
 196     _last_gc_worker_end_times_ms.set(worker_i, ms);
 197   }
 198 
 199   void record_clear_ct_time(double ms) {
 200     _cur_clear_ct_time_ms = ms;
 201   }
 202 
 203   void record_par_time(double ms) {
 204     _cur_collection_par_time_ms = ms;
 205   }
 206 
 207   void record_code_root_fixup_time(double ms) {
 208     _cur_collection_code_root_fixup_time_ms = ms;
 209   }
 210 




 211   void record_ref_proc_time(double ms) {
 212     _cur_ref_proc_time_ms = ms;
 213   }
 214 
 215   void record_ref_enq_time(double ms) {
 216     _cur_ref_enq_time_ms = ms;
 217   }
 218 
 219   void record_root_region_scan_wait_time(double time_ms) {
 220     _root_region_scan_wait_time_ms = time_ms;
 221   }
 222 
 223   void record_young_free_cset_time_ms(double time_ms) {
 224     _recorded_young_free_cset_time_ms = time_ms;
 225   }
 226 
 227   void record_non_young_free_cset_time_ms(double time_ms) {
 228     _recorded_non_young_free_cset_time_ms = time_ms;
 229   }
 230 


 277   double non_young_cset_choice_time_ms() {
 278     return _recorded_non_young_cset_choice_time_ms;
 279   }
 280 
 281   double non_young_free_cset_time_ms() {
 282     return _recorded_non_young_free_cset_time_ms;
 283   }
 284 
 285   double average_last_update_rs_time() {
 286     return _last_update_rs_times_ms.average();
 287   }
 288 
 289   int sum_last_update_rs_processed_buffers() {
 290     return _last_update_rs_processed_buffers.sum();
 291   }
 292 
 293   double average_last_scan_rs_time(){
 294     return _last_scan_rs_times_ms.average();
 295   }
 296 








 297   double average_last_obj_copy_time() {
 298     return _last_obj_copy_times_ms.average();
 299   }
 300 
 301   double average_last_termination_time() {
 302     return _last_termination_times_ms.average();
 303   }
 304 
 305   double average_last_ext_root_scan_time() {
 306     return _last_ext_root_scan_times_ms.average();
 307   }
 308 
 309   double average_last_satb_filtering_times_ms() {
 310     return _last_satb_filtering_times_ms.average();
 311   }
 312 };
 313 
 314 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1GCPHASETIMESLOG_HPP


 102     for (uint i = 0; i < _length; ++i) {
 103       _sum += _data[i];
 104     }
 105     _average = (double)_sum / (double)_length;
 106     _has_new_data = false;
 107   }
 108 };
 109 
 110 class G1GCPhaseTimes : public CHeapObj<mtGC> {
 111 
 112  private:
 113   uint _active_gc_threads;
 114   uint _max_gc_threads;
 115 
 116   WorkerDataArray<double> _last_gc_worker_start_times_ms;
 117   WorkerDataArray<double> _last_ext_root_scan_times_ms;
 118   WorkerDataArray<double> _last_satb_filtering_times_ms;
 119   WorkerDataArray<double> _last_update_rs_times_ms;
 120   WorkerDataArray<int>    _last_update_rs_processed_buffers;
 121   WorkerDataArray<double> _last_scan_rs_times_ms;
 122   WorkerDataArray<double> _last_strong_code_root_scan_times_ms;
 123   WorkerDataArray<double> _last_strong_code_root_mark_times_ms;
 124   WorkerDataArray<double> _last_obj_copy_times_ms;
 125   WorkerDataArray<double> _last_termination_times_ms;
 126   WorkerDataArray<size_t> _last_termination_attempts;
 127   WorkerDataArray<double> _last_gc_worker_end_times_ms;
 128   WorkerDataArray<double> _last_gc_worker_times_ms;
 129   WorkerDataArray<double> _last_gc_worker_other_times_ms;
 130 
 131   double _cur_collection_par_time_ms;
 132   double _cur_collection_code_root_fixup_time_ms;
 133   double _cur_strong_code_root_migration_time_ms;
 134 
 135   double _cur_clear_ct_time_ms;
 136   double _cur_ref_proc_time_ms;
 137   double _cur_ref_enq_time_ms;
 138 
 139   double _cur_collection_start_sec;
 140   double _root_region_scan_wait_time_ms;
 141 
 142   double _recorded_young_cset_choice_time_ms;
 143   double _recorded_non_young_cset_choice_time_ms;
 144 
 145   double _recorded_young_free_cset_time_ms;
 146   double _recorded_non_young_free_cset_time_ms;
 147 
 148   double _cur_verify_before_time_ms;
 149   double _cur_verify_after_time_ms;
 150 
 151   // Helper methods for detailed logging
 152   void print_stats(int level, const char* str, double value);
 153   void print_stats(int level, const char* str, double value, int workers);


 165   void record_ext_root_scan_time(uint worker_i, double ms) {
 166     _last_ext_root_scan_times_ms.set(worker_i, ms);
 167   }
 168 
 169   void record_satb_filtering_time(uint worker_i, double ms) {
 170     _last_satb_filtering_times_ms.set(worker_i, ms);
 171   }
 172 
 173   void record_update_rs_time(uint worker_i, double ms) {
 174     _last_update_rs_times_ms.set(worker_i, ms);
 175   }
 176 
 177   void record_update_rs_processed_buffers(uint worker_i, int processed_buffers) {
 178     _last_update_rs_processed_buffers.set(worker_i, processed_buffers);
 179   }
 180 
 181   void record_scan_rs_time(uint worker_i, double ms) {
 182     _last_scan_rs_times_ms.set(worker_i, ms);
 183   }
 184 
 185   void record_strong_code_root_scan_time(uint worker_i, double ms) {
 186     _last_strong_code_root_scan_times_ms.set(worker_i, ms);
 187   }
 188 
 189   void record_strong_code_root_mark_time(uint worker_i, double ms) {
 190     _last_strong_code_root_mark_times_ms.set(worker_i, ms);
 191   }
 192 
 193   void record_obj_copy_time(uint worker_i, double ms) {
 194     _last_obj_copy_times_ms.set(worker_i, ms);
 195   }
 196 
 197   void add_obj_copy_time(uint worker_i, double ms) {
 198     _last_obj_copy_times_ms.add(worker_i, ms);
 199   }
 200 
 201   void record_termination(uint worker_i, double ms, size_t attempts) {
 202     _last_termination_times_ms.set(worker_i, ms);
 203     _last_termination_attempts.set(worker_i, attempts);
 204   }
 205 
 206   void record_gc_worker_end_time(uint worker_i, double ms) {
 207     _last_gc_worker_end_times_ms.set(worker_i, ms);
 208   }
 209 
 210   void record_clear_ct_time(double ms) {
 211     _cur_clear_ct_time_ms = ms;
 212   }
 213 
 214   void record_par_time(double ms) {
 215     _cur_collection_par_time_ms = ms;
 216   }
 217 
 218   void record_code_root_fixup_time(double ms) {
 219     _cur_collection_code_root_fixup_time_ms = ms;
 220   }
 221 
 222   void record_strong_code_root_migration_time(double ms) {
 223     _cur_strong_code_root_migration_time_ms = ms;
 224   }
 225 
 226   void record_ref_proc_time(double ms) {
 227     _cur_ref_proc_time_ms = ms;
 228   }
 229 
 230   void record_ref_enq_time(double ms) {
 231     _cur_ref_enq_time_ms = ms;
 232   }
 233 
 234   void record_root_region_scan_wait_time(double time_ms) {
 235     _root_region_scan_wait_time_ms = time_ms;
 236   }
 237 
 238   void record_young_free_cset_time_ms(double time_ms) {
 239     _recorded_young_free_cset_time_ms = time_ms;
 240   }
 241 
 242   void record_non_young_free_cset_time_ms(double time_ms) {
 243     _recorded_non_young_free_cset_time_ms = time_ms;
 244   }
 245 


 292   double non_young_cset_choice_time_ms() {
 293     return _recorded_non_young_cset_choice_time_ms;
 294   }
 295 
 296   double non_young_free_cset_time_ms() {
 297     return _recorded_non_young_free_cset_time_ms;
 298   }
 299 
 300   double average_last_update_rs_time() {
 301     return _last_update_rs_times_ms.average();
 302   }
 303 
 304   int sum_last_update_rs_processed_buffers() {
 305     return _last_update_rs_processed_buffers.sum();
 306   }
 307 
 308   double average_last_scan_rs_time(){
 309     return _last_scan_rs_times_ms.average();
 310   }
 311 
 312   double average_last_strong_code_root_scan_time(){
 313     return _last_strong_code_root_scan_times_ms.average();
 314   }
 315 
 316   double average_last_strong_code_root_mark_time(){
 317     return _last_strong_code_root_mark_times_ms.average();
 318   }
 319 
 320   double average_last_obj_copy_time() {
 321     return _last_obj_copy_times_ms.average();
 322   }
 323 
 324   double average_last_termination_time() {
 325     return _last_termination_times_ms.average();
 326   }
 327 
 328   double average_last_ext_root_scan_time() {
 329     return _last_ext_root_scan_times_ms.average();
 330   }
 331 
 332   double average_last_satb_filtering_times_ms() {
 333     return _last_satb_filtering_times_ms.average();
 334   }
 335 };
 336 
 337 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1GCPHASETIMESLOG_HPP