1 /*

     2  * Copyright (c) 2013, 2015, 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 "memory/allocation.hpp"

    29 

    30 class LineBuffer;

    31 

    32 template <class T> class WorkerDataArray;

    33 

    34 class G1GCPhaseTimes : public CHeapObj<mtGC> {

    35   friend class G1GCParPhasePrinter;

    36 

    37   uint _active_gc_threads;

    38   uint _max_gc_threads;

    39 

    40  public:

    41   enum GCParPhases {

    42     GCWorkerStart,

    43     ExtRootScan,

    44     ThreadRoots,

    45     StringTableRoots,

    46     UniverseRoots,

    47     JNIRoots,

    48     ObjectSynchronizerRoots,

    49     FlatProfilerRoots,

    50     ManagementRoots,

    51     SystemDictionaryRoots,

    52     CLDGRoots,

    53     JVMTIRoots,

    54     CMRefRoots,

    55     WaitForStrongCLD,

    56     WeakCLDRoots,

    57     SATBFiltering,

    58     UpdateRS,

    59     ScanRS,

    60     CodeRoots,

    61     ObjCopy,

    62     Termination,

    63     Other,

    64     GCWorkerTotal,

    65     GCWorkerEnd,

    66     StringDedupQueueFixup,

    67     StringDedupTableFixup,

    68     RedirtyCards,

    69     GCParPhasesSentinel

    70   };

    71 

    72  private:

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

    74   static const int GCMainParPhasesLast = GCWorkerEnd;

    75   static const int StringDedupPhasesFirst = StringDedupQueueFixup;

    76   static const int StringDedupPhasesLast = StringDedupTableFixup;

    77 

    78   WorkerDataArray<double>* _gc_par_phases[GCParPhasesSentinel];

    79   WorkerDataArray<size_t>* _update_rs_processed_buffers;

    80   WorkerDataArray<size_t>* _termination_attempts;

    81   WorkerDataArray<size_t>* _redirtied_cards;

    82 

    83   double _cur_collection_par_time_ms;

    84   double _cur_collection_code_root_fixup_time_ms;

    85   double _cur_strong_code_root_purge_time_ms;

    86 

    87   double _cur_evac_fail_recalc_used;

    88   double _cur_evac_fail_restore_remsets;

    89   double _cur_evac_fail_remove_self_forwards;

    90 

    91   double _cur_string_dedup_fixup_time_ms;

    92 

    93   double _cur_clear_ct_time_ms;

    94   double _cur_ref_proc_time_ms;

    95   double _cur_ref_enq_time_ms;

    96 

    97   double _cur_collection_start_sec;

    98   double _root_region_scan_wait_time_ms;

    99 

   100   double _recorded_young_cset_choice_time_ms;

   101   double _recorded_non_young_cset_choice_time_ms;

   102 

   103   double _recorded_redirty_logged_cards_time_ms;

   104 

   105   double _recorded_young_free_cset_time_ms;

   106   double _recorded_non_young_free_cset_time_ms;

   107 

   108   double _cur_fast_reclaim_humongous_time_ms;

   109   double _cur_fast_reclaim_humongous_register_time_ms;

   110   size_t _cur_fast_reclaim_humongous_total;

   111   size_t _cur_fast_reclaim_humongous_candidates;

   112   size_t _cur_fast_reclaim_humongous_reclaimed;

   113 

   114   double _cur_verify_before_time_ms;

   115   double _cur_verify_after_time_ms;

   116 

   117   // Helper methods for detailed logging

   118   void print_stats(int level, const char* str, double value);

   119   void print_stats(int level, const char* str, size_t value);

   120   void print_stats(int level, const char* str, double value, uint workers);

   121 

   122  public:

   123   G1GCPhaseTimes(uint max_gc_threads);

   124   void note_gc_start(uint active_gc_threads, bool mark_in_progress);

   125   void note_gc_end();

   126   void print(double pause_time_sec);

   127 

   128   // record the time a phase took in seconds

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

   130 

   131   // add a number of seconds to a phase

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

   133 

   134   void record_thread_work_item(GCParPhases phase, uint worker_i, size_t count);

   135 

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

   137   double average_time_ms(GCParPhases phase);

   138 

   139   size_t sum_thread_work_items(GCParPhases phase);

   140 

   141  private:

   142   double get_time_ms(GCParPhases phase, uint worker_i);

   143   double sum_time_ms(GCParPhases phase);

   144   double min_time_ms(GCParPhases phase);

   145   double max_time_ms(GCParPhases phase);

   146   size_t get_thread_work_item(GCParPhases phase, uint worker_i);

   147   double average_thread_work_items(GCParPhases phase);

   148   size_t min_thread_work_items(GCParPhases phase);

   149   size_t max_thread_work_items(GCParPhases phase);

   150 

   151  public:

   152 

   153   void record_clear_ct_time(double ms) {

   154     _cur_clear_ct_time_ms = ms;

   155   }

   156 

   157   void record_par_time(double ms) {

   158     _cur_collection_par_time_ms = ms;

   159   }

   160 

   161   void record_code_root_fixup_time(double ms) {

   162     _cur_collection_code_root_fixup_time_ms = ms;

   163   }

   164 

   165   void record_strong_code_root_purge_time(double ms) {

   166     _cur_strong_code_root_purge_time_ms = ms;

   167   }

   168 

   169   void record_evac_fail_recalc_used_time(double ms) {

   170     _cur_evac_fail_recalc_used = ms;

   171   }

   172 

   173   void record_evac_fail_restore_remsets(double ms) {

   174     _cur_evac_fail_restore_remsets = ms;

   175   }

   176 

   177   void record_evac_fail_remove_self_forwards(double ms) {

   178     _cur_evac_fail_remove_self_forwards = ms;

   179   }

   180 

   181   void record_string_dedup_fixup_time(double ms) {

   182     _cur_string_dedup_fixup_time_ms = ms;

   183   }

   184 

   185   void record_ref_proc_time(double ms) {

   186     _cur_ref_proc_time_ms = ms;

   187   }

   188 

   189   void record_ref_enq_time(double ms) {

   190     _cur_ref_enq_time_ms = ms;

   191   }

   192 

   193   void record_root_region_scan_wait_time(double time_ms) {

   194     _root_region_scan_wait_time_ms = time_ms;

   195   }

   196 

   197   void record_young_free_cset_time_ms(double time_ms) {

   198     _recorded_young_free_cset_time_ms = time_ms;

   199   }

   200 

   201   void record_non_young_free_cset_time_ms(double time_ms) {

   202     _recorded_non_young_free_cset_time_ms = time_ms;

   203   }

   204 

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

   206     _cur_fast_reclaim_humongous_register_time_ms = time_ms;

   207     _cur_fast_reclaim_humongous_total = total;

   208     _cur_fast_reclaim_humongous_candidates = candidates;

   209   }

   210 

   211   void record_fast_reclaim_humongous_time_ms(double value, size_t reclaimed) {

   212     _cur_fast_reclaim_humongous_time_ms = value;

   213     _cur_fast_reclaim_humongous_reclaimed = reclaimed;

   214   }

   215 

   216   void record_young_cset_choice_time_ms(double time_ms) {

   217     _recorded_young_cset_choice_time_ms = time_ms;

   218   }

   219 

   220   void record_non_young_cset_choice_time_ms(double time_ms) {

   221     _recorded_non_young_cset_choice_time_ms = time_ms;

   222   }

   223 

   224   void record_redirty_logged_cards_time_ms(double time_ms) {

   225     _recorded_redirty_logged_cards_time_ms = time_ms;

   226   }

   227 

   228   void record_cur_collection_start_sec(double time_ms) {

   229     _cur_collection_start_sec = time_ms;

   230   }

   231 

   232   void record_verify_before_time_ms(double time_ms) {

   233     _cur_verify_before_time_ms = time_ms;

   234   }

   235 

   236   void record_verify_after_time_ms(double time_ms) {

   237     _cur_verify_after_time_ms = time_ms;

   238   }

   239 

   240   double accounted_time_ms();

   241 

   242   double cur_collection_start_sec() {

   243     return _cur_collection_start_sec;

   244   }

   245 

   246   double cur_collection_par_time_ms() {

   247     return _cur_collection_par_time_ms;

   248   }

   249 

   250   double cur_clear_ct_time_ms() {

   251     return _cur_clear_ct_time_ms;

   252   }

   253 

   254   double root_region_scan_wait_time_ms() {

   255     return _root_region_scan_wait_time_ms;

   256   }

   257 

   258   double young_cset_choice_time_ms() {

   259     return _recorded_young_cset_choice_time_ms;

   260   }

   261 

   262   double young_free_cset_time_ms() {

   263     return _recorded_young_free_cset_time_ms;

   264   }

   265 

   266   double non_young_cset_choice_time_ms() {

   267     return _recorded_non_young_cset_choice_time_ms;

   268   }

   269 

   270   double non_young_free_cset_time_ms() {

   271     return _recorded_non_young_free_cset_time_ms;

   272   }

   273 

   274   double fast_reclaim_humongous_time_ms() {

   275     return _cur_fast_reclaim_humongous_time_ms;

   276   }

   277 };

   278 

   279 class G1GCParPhaseTimesTracker : public StackObj {

   280   double _start_time;

   281   G1GCPhaseTimes::GCParPhases _phase;

   282   G1GCPhaseTimes* _phase_times;

   283   uint _worker_id;

   284 public:

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

   286   ~G1GCParPhaseTimesTracker();

   287 };

   288 

   289 #endif // SHARE_VM_GC_G1_G1GCPHASETIMES_HPP