1 /*

     2  * Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #ifndef SHARE_VM_GC_G1_G1GCPHASETIMES_HPP

    26 #define SHARE_VM_GC_G1_G1GCPHASETIMES_HPP

    27 

    28 #include "gc/shared/referenceProcessorPhaseTimes.hpp"

    29 #include "logging/logLevel.hpp"

    30 #include "memory/allocation.hpp"

    31 #include "utilities/macros.hpp"

    32 

    33 class LineBuffer;

    34 class STWGCTimer;

    35 

    36 template <class T> class WorkerDataArray;

    37 

    38 class G1GCPhaseTimes : public CHeapObj<mtGC> {

    39   uint _max_gc_threads;

    40   jlong _gc_start_counter;

    41   double _gc_pause_time_ms;

    42 

    43  public:

    44   enum GCParPhases {

    45     GCWorkerStart,

    46     ExtRootScan,

    47     ThreadRoots,

    48     StringTableRoots,

    49     UniverseRoots,

    50     JNIRoots,

    51     ObjectSynchronizerRoots,

    52     ManagementRoots,

    53     SystemDictionaryRoots,

    54     CLDGRoots,

    55     JVMTIRoots,

    56     CMRefRoots,

    57     WaitForStrongCLD,

    58     WeakCLDRoots,

    59     SATBFiltering,

    60     UpdateRS,

    61     ScanHCC,

    62     ScanRS,

    63     CodeRoots,

    64 #if INCLUDE_AOT

    65     AOTCodeRoots,

    66 #endif

    67     ObjCopy,

    68     Termination,

    69     Other,

    70     GCWorkerTotal,

    71     GCWorkerEnd,

    72     StringDedupQueueFixup,

    73     StringDedupTableFixup,

    74     RedirtyCards,

    75     PreserveCMReferents,

    76     YoungFreeCSet,

    77     NonYoungFreeCSet,

    78     GCParPhasesSentinel

    79   };

    80 

    81   enum GCScanRSWorkItems {

    82     ScanRSScannedCards,

    83     ScanRSClaimedCards,

    84     ScanRSSkippedCards

    85   };

    86 

    87   enum GCUpdateRSWorkItems {

    88     UpdateRSProcessedBuffers,

    89     UpdateRSScannedCards,

    90     UpdateRSSkippedCards

    91   };

    92 

    93  private:

    94   // Markers for grouping the phases in the GCPhases enum above

    95   static const int GCMainParPhasesLast = GCWorkerEnd;

    96   static const int StringDedupPhasesFirst = StringDedupQueueFixup;

    97   static const int StringDedupPhasesLast = StringDedupTableFixup;

    98 

    99   WorkerDataArray<double>* _gc_par_phases[GCParPhasesSentinel];

   100 

   101   WorkerDataArray<size_t>* _update_rs_processed_buffers;

   102   WorkerDataArray<size_t>* _update_rs_scanned_cards;

   103   WorkerDataArray<size_t>* _update_rs_skipped_cards;

   104 

   105   WorkerDataArray<size_t>* _scan_rs_scanned_cards;

   106   WorkerDataArray<size_t>* _scan_rs_claimed_cards;

   107   WorkerDataArray<size_t>* _scan_rs_skipped_cards;

   108 

   109   WorkerDataArray<size_t>* _termination_attempts;

   110 

   111   WorkerDataArray<size_t>* _redirtied_cards;

   112 

   113   double _cur_collection_par_time_ms;

   114   double _cur_collection_code_root_fixup_time_ms;

   115   double _cur_strong_code_root_purge_time_ms;

   116 

   117   double _cur_evac_fail_recalc_used;

   118   double _cur_evac_fail_remove_self_forwards;

   119 

   120   double _cur_string_dedup_fixup_time_ms;

   121 

   122   double _cur_prepare_tlab_time_ms;

   123   double _cur_resize_tlab_time_ms;

   124 

   125   double _cur_derived_pointer_table_update_time_ms;

   126 

   127   double _cur_clear_ct_time_ms;

   128   double _cur_expand_heap_time_ms;

   129   double _cur_ref_proc_time_ms;

   130   double _cur_ref_enq_time_ms;

   131 

   132   double _cur_collection_start_sec;

   133   double _root_region_scan_wait_time_ms;

   134 

   135   double _external_accounted_time_ms;

   136 

   137   double _recorded_clear_claimed_marks_time_ms;

   138 

   139   double _recorded_young_cset_choice_time_ms;

   140   double _recorded_non_young_cset_choice_time_ms;

   141 

   142   double _recorded_redirty_logged_cards_time_ms;

   143 

   144   double _recorded_preserve_cm_referents_time_ms;

   145 

   146   double _recorded_merge_pss_time_ms;

   147 

   148   double _recorded_start_new_cset_time_ms;

   149 

   150   double _recorded_total_free_cset_time_ms;

   151 

   152   double _recorded_serial_free_cset_time_ms;

   153 

   154   double _cur_fast_reclaim_humongous_time_ms;

   155   double _cur_fast_reclaim_humongous_register_time_ms;

   156   size_t _cur_fast_reclaim_humongous_total;

   157   size_t _cur_fast_reclaim_humongous_candidates;

   158   size_t _cur_fast_reclaim_humongous_reclaimed;

   159 

   160   double _cur_verify_before_time_ms;

   161   double _cur_verify_after_time_ms;

   162 

   163   ReferenceProcessorPhaseTimes _ref_phase_times;

   164 

   165   double worker_time(GCParPhases phase, uint worker);

   166   void note_gc_end();

   167   void reset();

   168 

   169   template <class T>

   170   void details(T* phase, const char* indent) const;

   171 

   172   void log_phase(WorkerDataArray<double>* phase, uint indent, outputStream* out, bool print_sum) const;

   173   void debug_phase(WorkerDataArray<double>* phase) const;

   174   void trace_phase(WorkerDataArray<double>* phase, bool print_sum = true) const;

   175 

   176   void info_time(const char* name, double value) const;

   177   void debug_time(const char* name, double value) const;

   178   // This will print logs for both 'gc+phases' and 'gc+phases+ref'.

   179   void debug_time_for_reference(const char* name, double value) const;

   180   void trace_time(const char* name, double value) const;

   181   void trace_count(const char* name, size_t value) const;

   182 

   183   double print_pre_evacuate_collection_set() const;

   184   double print_evacuate_collection_set() const;

   185   double print_post_evacuate_collection_set() const;

   186   void print_other(double accounted_ms) const;

   187 

   188  public:

   189   G1GCPhaseTimes(STWGCTimer* gc_timer, uint max_gc_threads);

   190   void note_gc_start();

   191   void print();

   192 

   193   // record the time a phase took in seconds

   194   void record_time_secs(GCParPhases phase, uint worker_i, double secs);

   195 

   196   // add a number of seconds to a phase

   197   void add_time_secs(GCParPhases phase, uint worker_i, double secs);

   198 

   199   void record_thread_work_item(GCParPhases phase, uint worker_i, size_t count, uint index = 0);

   200 

   201   // return the average time for a phase in milliseconds

   202   double average_time_ms(GCParPhases phase);

   203 

   204   size_t sum_thread_work_items(GCParPhases phase, uint index = 0);

   205 

   206  public:

   207 

   208   void record_prepare_tlab_time_ms(double ms) {

   209     _cur_prepare_tlab_time_ms = ms;

   210   }

   211 

   212   void record_resize_tlab_time_ms(double ms) {

   213     _cur_resize_tlab_time_ms = ms;

   214   }

   215 

   216   void record_derived_pointer_table_update_time(double ms) {

   217     _cur_derived_pointer_table_update_time_ms = ms;

   218   }

   219 

   220   void record_clear_ct_time(double ms) {

   221     _cur_clear_ct_time_ms = ms;

   222   }

   223 

   224   void record_expand_heap_time(double ms) {

   225     _cur_expand_heap_time_ms = ms;

   226   }

   227 

   228   void record_par_time(double ms) {

   229     _cur_collection_par_time_ms = ms;

   230   }

   231 

   232   void record_code_root_fixup_time(double ms) {

   233     _cur_collection_code_root_fixup_time_ms = ms;

   234   }

   235 

   236   void record_strong_code_root_purge_time(double ms) {

   237     _cur_strong_code_root_purge_time_ms = ms;

   238   }

   239 

   240   void record_evac_fail_recalc_used_time(double ms) {

   241     _cur_evac_fail_recalc_used = ms;

   242   }

   243 

   244   void record_evac_fail_remove_self_forwards(double ms) {

   245     _cur_evac_fail_remove_self_forwards = ms;

   246   }

   247 

   248   void record_string_dedup_fixup_time(double ms) {

   249     _cur_string_dedup_fixup_time_ms = ms;

   250   }

   251 

   252   void record_ref_proc_time(double ms) {

   253     _cur_ref_proc_time_ms = ms;

   254   }

   255 

   256   void record_ref_enq_time(double ms) {

   257     _cur_ref_enq_time_ms = ms;

   258   }

   259 

   260   void record_root_region_scan_wait_time(double time_ms) {

   261     _root_region_scan_wait_time_ms = time_ms;

   262   }

   263 

   264   void record_total_free_cset_time_ms(double time_ms) {

   265     _recorded_total_free_cset_time_ms = time_ms;

   266   }

   267 

   268   void record_serial_free_cset_time_ms(double time_ms) {

   269     _recorded_serial_free_cset_time_ms = time_ms;

   270   }

   271 

   272   void record_fast_reclaim_humongous_stats(double time_ms, size_t total, size_t candidates) {

   273     _cur_fast_reclaim_humongous_register_time_ms = time_ms;

   274     _cur_fast_reclaim_humongous_total = total;

   275     _cur_fast_reclaim_humongous_candidates = candidates;

   276   }

   277 

   278   void record_fast_reclaim_humongous_time_ms(double value, size_t reclaimed) {

   279     _cur_fast_reclaim_humongous_time_ms = value;

   280     _cur_fast_reclaim_humongous_reclaimed = reclaimed;

   281   }

   282 

   283   void record_young_cset_choice_time_ms(double time_ms) {

   284     _recorded_young_cset_choice_time_ms = time_ms;

   285   }

   286 

   287   void record_non_young_cset_choice_time_ms(double time_ms) {

   288     _recorded_non_young_cset_choice_time_ms = time_ms;

   289   }

   290 

   291   void record_redirty_logged_cards_time_ms(double time_ms) {

   292     _recorded_redirty_logged_cards_time_ms = time_ms;

   293   }

   294 

   295   void record_preserve_cm_referents_time_ms(double time_ms) {

   296     _recorded_preserve_cm_referents_time_ms = time_ms;

   297   }

   298 

   299   void record_merge_pss_time_ms(double time_ms) {

   300     _recorded_merge_pss_time_ms = time_ms;

   301   }

   302 

   303   void record_start_new_cset_time_ms(double time_ms) {

   304     _recorded_start_new_cset_time_ms = time_ms;

   305   }

   306 

   307   void record_cur_collection_start_sec(double time_ms) {

   308     _cur_collection_start_sec = time_ms;

   309   }

   310 

   311   void record_verify_before_time_ms(double time_ms) {

   312     _cur_verify_before_time_ms = time_ms;

   313   }

   314 

   315   void record_verify_after_time_ms(double time_ms) {

   316     _cur_verify_after_time_ms = time_ms;

   317   }

   318 

   319   void inc_external_accounted_time_ms(double time_ms) {

   320     _external_accounted_time_ms += time_ms;

   321   }

   322 

   323   void record_clear_claimed_marks_time_ms(double recorded_clear_claimed_marks_time_ms) {

   324     _recorded_clear_claimed_marks_time_ms = recorded_clear_claimed_marks_time_ms;

   325   }

   326 

   327   double cur_collection_start_sec() {

   328     return _cur_collection_start_sec;

   329   }

   330 

   331   double cur_collection_par_time_ms() {

   332     return _cur_collection_par_time_ms;

   333   }

   334 

   335   double cur_clear_ct_time_ms() {

   336     return _cur_clear_ct_time_ms;

   337   }

   338 

   339   double cur_expand_heap_time_ms() {

   340     return _cur_expand_heap_time_ms;

   341   }

   342 

   343   double root_region_scan_wait_time_ms() {

   344     return _root_region_scan_wait_time_ms;

   345   }

   346 

   347   double young_cset_choice_time_ms() {

   348     return _recorded_young_cset_choice_time_ms;

   349   }

   350 

   351   double total_free_cset_time_ms() {

   352     return _recorded_total_free_cset_time_ms;

   353   }

   354 

   355   double non_young_cset_choice_time_ms() {

   356     return _recorded_non_young_cset_choice_time_ms;

   357   }

   358 

   359   double fast_reclaim_humongous_time_ms() {

   360     return _cur_fast_reclaim_humongous_time_ms;

   361   }

   362 

   363   ReferenceProcessorPhaseTimes* ref_phase_times() { return &_ref_phase_times; }

   364 };

   365 

   366 class G1GCParPhaseTimesTracker : public StackObj {

   367   double _start_time;

   368   G1GCPhaseTimes::GCParPhases _phase;

   369   G1GCPhaseTimes* _phase_times;

   370   uint _worker_id;

   371 public:

   372   G1GCParPhaseTimesTracker(G1GCPhaseTimes* phase_times, G1GCPhaseTimes::GCParPhases phase, uint worker_id);

   373   ~G1GCParPhaseTimesTracker();

   374 };

   375 

   376 #endif // SHARE_VM_GC_G1_G1GCPHASETIMES_HPP