< prev index next >

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

Print this page

 27 
 28 #include "jfr/jfrEvents.hpp"
 29 #include "gc/shenandoah/shenandoahNumberSeq.hpp"
 30 #include "gc/shared/workerDataArray.hpp"
 31 #include "memory/allocation.hpp"
 32 
 33 class ShenandoahCollectorPolicy;
 34 class outputStream;
 35 
 36 #define SHENANDOAH_PAR_PHASE_DO(CNT_PREFIX, DESC_PREFIX, f)                            \
 37   f(CNT_PREFIX ## TotalWork,                DESC_PREFIX "<total>")                     \
 38   f(CNT_PREFIX ## ThreadRoots,              DESC_PREFIX "Thread Roots")                \
 39   f(CNT_PREFIX ## CodeCacheRoots,           DESC_PREFIX "Code Cache Roots")            \
 40   f(CNT_PREFIX ## VMStrongRoots,            DESC_PREFIX "VM Strong Roots")             \
 41   f(CNT_PREFIX ## VMWeakRoots,              DESC_PREFIX "VM Weak Roots")               \
 42   f(CNT_PREFIX ## CLDGRoots,                DESC_PREFIX "CLDG Roots")                  \
 43   f(CNT_PREFIX ## CodeCacheUnload,          DESC_PREFIX "Unload Code Caches")          \
 44   f(CNT_PREFIX ## CLDUnlink,                DESC_PREFIX "Unlink CLDs")                 \
 45   f(CNT_PREFIX ## WeakRefProc,              DESC_PREFIX "Weak References")             \
 46   f(CNT_PREFIX ## ParallelMark,             DESC_PREFIX "Parallel Mark")               \

 47   // end
 48 
 49 #define SHENANDOAH_PHASE_DO(f)                                                         \
 50   f(conc_reset,                                     "Concurrent Reset")                \
 51                                                                                        \
 52   f(init_mark_gross,                                "Pause Init Mark (G)")             \
 53   f(init_mark,                                      "Pause Init Mark (N)")             \
 54   f(init_manage_tlabs,                              "  Manage TLABs")                  \


 55   f(init_update_region_states,                      "  Update Region States")          \
 56                                                                                        \



 57   f(conc_mark_roots,                                "Concurrent Mark Roots ")          \
 58   SHENANDOAH_PAR_PHASE_DO(conc_mark_roots,          "  CMR: ", f)                      \
 59   f(conc_mark,                                      "Concurrent Marking")              \

 60                                                                                        \
 61   f(final_mark_gross,                               "Pause Final Mark (G)")            \
 62   f(final_mark,                                     "Pause Final Mark (N)")            \
 63   f(finish_mark,                                    "  Finish Mark")                   \
 64   SHENANDOAH_PAR_PHASE_DO(finish_mark_,             "    FM: ", f)                     \
 65   f(purge,                                          "  System Purge")                  \
 66   SHENANDOAH_PAR_PHASE_DO(purge_cu_par_,            "      CU: ", f)                   \
 67   f(purge_weak_par,                                 "    Weak Roots")                  \
 68   SHENANDOAH_PAR_PHASE_DO(purge_weak_par_,          "      WR: ", f)                   \
 69   f(final_update_region_states,                     "  Update Region States")          \
 70   f(final_manage_labs,                              "  Manage GC/TLABs")               \
 71   f(choose_cset,                                    "  Choose Collection Set")         \
 72   f(final_rebuild_freeset,                          "  Rebuild Free Set")              \
 73   f(init_evac,                                      "  Initial Evacuation")            \
 74   SHENANDOAH_PAR_PHASE_DO(evac_,                    "    E: ", f)                      \
 75                                                                                        \
 76   f(conc_thread_roots,                              "Concurrent Thread Roots")         \
 77   SHENANDOAH_PAR_PHASE_DO(conc_thread_roots_,       "  CTR: ", f)                      \
 78   f(conc_weak_refs,                                 "Concurrent Weak References")      \
 79   SHENANDOAH_PAR_PHASE_DO(conc_weak_refs_,          "  CWRF: ", f)                     \
 80   f(conc_weak_roots,                                "Concurrent Weak Roots")           \
 81   f(conc_weak_roots_work,                           "  Roots")                         \
 82   SHENANDOAH_PAR_PHASE_DO(conc_weak_roots_work_,    "    CWR: ", f)                    \
 83   f(conc_weak_roots_rendezvous,                     "  Rendezvous")                    \
 84   f(conc_cleanup_early,                             "Concurrent Cleanup")              \
 85   f(conc_class_unload,                              "Concurrent Class Unloading")      \
 86   f(conc_class_unload_unlink,                       "  Unlink Stale")                  \
 87   f(conc_class_unload_unlink_sd,                    "    System Dictionary")           \
 88   f(conc_class_unload_unlink_weak_klass,            "    Weak Class Links")            \
 89   f(conc_class_unload_unlink_code_roots,            "    Code Roots")                  \
 90   f(conc_class_unload_rendezvous,                   "  Rendezvous")                    \
 91   f(conc_class_unload_purge,                        "  Purge Unlinked")                \
 92   f(conc_class_unload_purge_coderoots,              "    Code Roots")                  \
 93   f(conc_class_unload_purge_cldg,                   "    CLDG")                        \
 94   f(conc_class_unload_purge_ec,                     "    Exception Caches")            \
 95   f(conc_strong_roots,                              "Concurrent Strong Roots")         \
 96   SHENANDOAH_PAR_PHASE_DO(conc_strong_roots_,       "  CSR: ", f)                      \


 97   f(conc_evac,                                      "Concurrent Evacuation")           \
 98                                                                                        \
 99   f(final_roots_gross,                              "Pause Final Roots (G)")           \
100   f(final_roots,                                    "Pause Final Roots (N)")           \
101                                                                                        \
102   f(init_update_refs_gross,                         "Pause Init Update Refs (G)")      \
103   f(init_update_refs,                               "Pause Init Update Refs (N)")      \
104   f(init_update_refs_manage_gclabs,                 "  Manage GCLABs")                 \
105                                                                                        \
106   f(conc_update_refs,                               "Concurrent Update Refs")          \
107   f(conc_update_thread_roots,                       "Concurrent Update Thread Roots")  \
108                                                                                        \
109   f(final_update_refs_gross,                        "Pause Final Update Refs (G)")     \
110   f(final_update_refs,                              "Pause Final Update Refs (N)")     \
111   f(final_update_refs_finish_work,                  "  Finish Work")                   \
112   f(final_update_refs_update_region_states,         "  Update Region States")          \
113   f(final_update_refs_trash_cset,                   "  Trash Collection Set")          \
114   f(final_update_refs_rebuild_freeset,              "  Rebuild Free Set")              \
115                                                                                        \
116   f(conc_cleanup_complete,                          "Concurrent Cleanup")              \

154   SHENANDOAH_PAR_PHASE_DO(full_gc_mark_,            "    FM: ", f)                     \
155   f(full_gc_purge,                                  "    System Purge")                \
156   f(full_gc_weakrefs,                               "      Weak References")           \
157   SHENANDOAH_PAR_PHASE_DO(full_gc_weakrefs_p_,      "        WRP: ", f)                \
158   f(full_gc_purge_class_unload,                     "      Unload Classes")            \
159   SHENANDOAH_PAR_PHASE_DO(full_gc_purge_cu_par_,    "        CU: ", f)                 \
160   f(full_gc_purge_weak_par,                         "      Weak Roots")                \
161   SHENANDOAH_PAR_PHASE_DO(full_gc_purge_weak_p_,    "        WR: ", f)                 \
162   f(full_gc_purge_cldg,                             "      CLDG")                      \
163   f(full_gc_calculate_addresses,                    "  Calculate Addresses")           \
164   f(full_gc_calculate_addresses_regular,            "    Regular Objects")             \
165   f(full_gc_calculate_addresses_humong,             "    Humongous Objects")           \
166   f(full_gc_adjust_pointers,                        "  Adjust Pointers")               \
167   f(full_gc_adjust_roots,                           "  Adjust Roots")                  \
168   SHENANDOAH_PAR_PHASE_DO(full_gc_adjust_roots_,    "    FA: ", f)                     \
169   f(full_gc_copy_objects,                           "  Copy Objects")                  \
170   f(full_gc_copy_objects_regular,                   "    Regular Objects")             \
171   f(full_gc_copy_objects_humong,                    "    Humongous Objects")           \
172   f(full_gc_copy_objects_reset_complete,            "    Reset Complete Bitmap")       \
173   f(full_gc_copy_objects_rebuild,                   "    Rebuild Region Sets")         \

174   f(full_gc_heapdump_post,                          "  Post Heap Dump")                \
175                                                                                        \
176   f(conc_uncommit,                                  "Concurrent Uncommit")             \
177   f(pacing,                                         "Pacing")                          \
178                                                                                        \
179   f(heap_iteration_roots,                           "Heap Iteration")                  \
180   SHENANDOAH_PAR_PHASE_DO(heap_iteration_roots_,    "  HI: ", f)                       \
181   // end
182 
183 typedef WorkerDataArray<double> ShenandoahWorkerData;
184 
185 class ShenandoahPhaseTimings : public CHeapObj<mtGC> {
186   friend class ShenandoahGCPhase;
187   friend class ShenandoahWorkerTimingsTracker;
188 public:
189 #define SHENANDOAH_PHASE_DECLARE_ENUM(type, title)   type,
190 
191   enum Phase {
192     SHENANDOAH_PHASE_DO(SHENANDOAH_PHASE_DECLARE_ENUM)
193     _num_phases,

232 
233   static const char* phase_name(Phase phase) {
234     assert(phase >= 0 && phase < _num_phases, "Out of bound");
235     return _phase_names[phase];
236   }
237 
238   void print_cycle_on(outputStream* out) const;
239   void print_global_on(outputStream* out) const;
240 };
241 
242 class ShenandoahWorkerTimingsTracker : public StackObj {
243 private:
244   ShenandoahPhaseTimings*          const _timings;
245   ShenandoahPhaseTimings::Phase    const _phase;
246   ShenandoahPhaseTimings::ParPhase const _par_phase;
247   uint const _worker_id;
248 
249   double _start_time;
250   EventGCPhaseParallel _event;
251 public:
252   ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase, uint worker_id);

253   ~ShenandoahWorkerTimingsTracker();
254 };
255 
256 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHPHASETIMINGS_HPP

 27 
 28 #include "jfr/jfrEvents.hpp"
 29 #include "gc/shenandoah/shenandoahNumberSeq.hpp"
 30 #include "gc/shared/workerDataArray.hpp"
 31 #include "memory/allocation.hpp"
 32 
 33 class ShenandoahCollectorPolicy;
 34 class outputStream;
 35 
 36 #define SHENANDOAH_PAR_PHASE_DO(CNT_PREFIX, DESC_PREFIX, f)                            \
 37   f(CNT_PREFIX ## TotalWork,                DESC_PREFIX "<total>")                     \
 38   f(CNT_PREFIX ## ThreadRoots,              DESC_PREFIX "Thread Roots")                \
 39   f(CNT_PREFIX ## CodeCacheRoots,           DESC_PREFIX "Code Cache Roots")            \
 40   f(CNT_PREFIX ## VMStrongRoots,            DESC_PREFIX "VM Strong Roots")             \
 41   f(CNT_PREFIX ## VMWeakRoots,              DESC_PREFIX "VM Weak Roots")               \
 42   f(CNT_PREFIX ## CLDGRoots,                DESC_PREFIX "CLDG Roots")                  \
 43   f(CNT_PREFIX ## CodeCacheUnload,          DESC_PREFIX "Unload Code Caches")          \
 44   f(CNT_PREFIX ## CLDUnlink,                DESC_PREFIX "Unlink CLDs")                 \
 45   f(CNT_PREFIX ## WeakRefProc,              DESC_PREFIX "Weak References")             \
 46   f(CNT_PREFIX ## ParallelMark,             DESC_PREFIX "Parallel Mark")               \
 47   f(CNT_PREFIX ## ScanClusters,             DESC_PREFIX "Scan Clusters")
 48   // end
 49 
 50 #define SHENANDOAH_PHASE_DO(f)                                                         \
 51   f(conc_reset,                                     "Concurrent Reset")                \
 52                                                                                        \
 53   f(init_mark_gross,                                "Pause Init Mark (G)")             \
 54   f(init_mark,                                      "Pause Init Mark (N)")             \
 55   f(init_manage_tlabs,                              "  Manage TLABs")                  \
 56   f(init_swap_rset,                                 "  Swap Remembered Set")           \
 57   f(init_transfer_satb,                             "  Transfer Old From SATB")        \
 58   f(init_update_region_states,                      "  Update Region States")          \
 59                                                                                        \
 60   f(init_scan_rset,                                 "Concurrent Scan Remembered Set")  \
 61   SHENANDOAH_PAR_PHASE_DO(init_scan_rset_,          "  RS: ", f)                       \
 62                                                                                        \
 63   f(conc_mark_roots,                                "Concurrent Mark Roots ")          \
 64   SHENANDOAH_PAR_PHASE_DO(conc_mark_roots,          "  CMR: ", f)                      \
 65   f(conc_mark,                                      "Concurrent Marking")              \
 66   SHENANDOAH_PAR_PHASE_DO(conc_mark,                "  CM: ", f)                       \
 67                                                                                        \
 68   f(final_mark_gross,                               "Pause Final Mark (G)")            \
 69   f(final_mark,                                     "Pause Final Mark (N)")            \
 70   f(finish_mark,                                    "  Finish Mark")                   \
 71   SHENANDOAH_PAR_PHASE_DO(finish_mark_,             "    FM: ", f)                     \
 72   f(purge,                                          "  System Purge")                  \
 73   SHENANDOAH_PAR_PHASE_DO(purge_cu_par_,            "      CU: ", f)                   \
 74   f(purge_weak_par,                                 "    Weak Roots")                  \
 75   SHENANDOAH_PAR_PHASE_DO(purge_weak_par_,          "      WR: ", f)                   \
 76   f(final_update_region_states,                     "  Update Region States")          \
 77   f(final_manage_labs,                              "  Manage GC/TLABs")               \
 78   f(choose_cset,                                    "  Choose Collection Set")         \
 79   f(final_rebuild_freeset,                          "  Rebuild Free Set")              \
 80   f(init_evac,                                      "  Initial Evacuation")            \
 81   SHENANDOAH_PAR_PHASE_DO(evac_,                    "    E: ", f)                      \
 82                                                                                        \
 83   f(conc_thread_roots,                              "Concurrent Thread Roots")         \
 84   SHENANDOAH_PAR_PHASE_DO(conc_thread_roots_,       "  CTR: ", f)                      \
 85   f(conc_weak_refs,                                 "Concurrent Weak References")      \
 86   SHENANDOAH_PAR_PHASE_DO(conc_weak_refs_,          "  CWRF: ", f)                     \
 87   f(conc_weak_roots,                                "Concurrent Weak Roots")           \
 88   f(conc_weak_roots_work,                           "  Roots")                         \
 89   SHENANDOAH_PAR_PHASE_DO(conc_weak_roots_work_,    "    CWR: ", f)                    \
 90   f(conc_weak_roots_rendezvous,                     "  Rendezvous")                    \
 91   f(conc_cleanup_early,                             "Concurrent Cleanup")              \
 92   f(conc_class_unload,                              "Concurrent Class Unloading")      \
 93   f(conc_class_unload_unlink,                       "  Unlink Stale")                  \
 94   f(conc_class_unload_unlink_sd,                    "    System Dictionary")           \
 95   f(conc_class_unload_unlink_weak_klass,            "    Weak Class Links")            \
 96   f(conc_class_unload_unlink_code_roots,            "    Code Roots")                  \
 97   f(conc_class_unload_rendezvous,                   "  Rendezvous")                    \
 98   f(conc_class_unload_purge,                        "  Purge Unlinked")                \
 99   f(conc_class_unload_purge_coderoots,              "    Code Roots")                  \
100   f(conc_class_unload_purge_cldg,                   "    CLDG")                        \
101   f(conc_class_unload_purge_ec,                     "    Exception Caches")            \
102   f(conc_strong_roots,                              "Concurrent Strong Roots")         \
103   SHENANDOAH_PAR_PHASE_DO(conc_strong_roots_,       "  CSR: ", f)                      \
104   f(coalesce_and_fill,                              "Coalesce and Fill Old Dead")      \
105   SHENANDOAH_PAR_PHASE_DO(coalesce_and_fill_,       "    CFOD: ", f)                   \
106   f(conc_evac,                                      "Concurrent Evacuation")           \
107                                                                                        \
108   f(final_roots_gross,                              "Pause Final Roots (G)")           \
109   f(final_roots,                                    "Pause Final Roots (N)")           \
110                                                                                        \
111   f(init_update_refs_gross,                         "Pause Init Update Refs (G)")      \
112   f(init_update_refs,                               "Pause Init Update Refs (N)")      \
113   f(init_update_refs_manage_gclabs,                 "  Manage GCLABs")                 \
114                                                                                        \
115   f(conc_update_refs,                               "Concurrent Update Refs")          \
116   f(conc_update_thread_roots,                       "Concurrent Update Thread Roots")  \
117                                                                                        \
118   f(final_update_refs_gross,                        "Pause Final Update Refs (G)")     \
119   f(final_update_refs,                              "Pause Final Update Refs (N)")     \
120   f(final_update_refs_finish_work,                  "  Finish Work")                   \
121   f(final_update_refs_update_region_states,         "  Update Region States")          \
122   f(final_update_refs_trash_cset,                   "  Trash Collection Set")          \
123   f(final_update_refs_rebuild_freeset,              "  Rebuild Free Set")              \
124                                                                                        \
125   f(conc_cleanup_complete,                          "Concurrent Cleanup")              \

163   SHENANDOAH_PAR_PHASE_DO(full_gc_mark_,            "    FM: ", f)                     \
164   f(full_gc_purge,                                  "    System Purge")                \
165   f(full_gc_weakrefs,                               "      Weak References")           \
166   SHENANDOAH_PAR_PHASE_DO(full_gc_weakrefs_p_,      "        WRP: ", f)                \
167   f(full_gc_purge_class_unload,                     "      Unload Classes")            \
168   SHENANDOAH_PAR_PHASE_DO(full_gc_purge_cu_par_,    "        CU: ", f)                 \
169   f(full_gc_purge_weak_par,                         "      Weak Roots")                \
170   SHENANDOAH_PAR_PHASE_DO(full_gc_purge_weak_p_,    "        WR: ", f)                 \
171   f(full_gc_purge_cldg,                             "      CLDG")                      \
172   f(full_gc_calculate_addresses,                    "  Calculate Addresses")           \
173   f(full_gc_calculate_addresses_regular,            "    Regular Objects")             \
174   f(full_gc_calculate_addresses_humong,             "    Humongous Objects")           \
175   f(full_gc_adjust_pointers,                        "  Adjust Pointers")               \
176   f(full_gc_adjust_roots,                           "  Adjust Roots")                  \
177   SHENANDOAH_PAR_PHASE_DO(full_gc_adjust_roots_,    "    FA: ", f)                     \
178   f(full_gc_copy_objects,                           "  Copy Objects")                  \
179   f(full_gc_copy_objects_regular,                   "    Regular Objects")             \
180   f(full_gc_copy_objects_humong,                    "    Humongous Objects")           \
181   f(full_gc_copy_objects_reset_complete,            "    Reset Complete Bitmap")       \
182   f(full_gc_copy_objects_rebuild,                   "    Rebuild Region Sets")         \
183   f(full_gc_reconstruct_remembered_set,             "    Reconstruct Remembered Set")  \
184   f(full_gc_heapdump_post,                          "  Post Heap Dump")                \
185                                                                                        \
186   f(conc_uncommit,                                  "Concurrent Uncommit")             \
187   f(pacing,                                         "Pacing")                          \
188                                                                                        \
189   f(heap_iteration_roots,                           "Heap Iteration")                  \
190   SHENANDOAH_PAR_PHASE_DO(heap_iteration_roots_,    "  HI: ", f)                       \
191   // end
192 
193 typedef WorkerDataArray<double> ShenandoahWorkerData;
194 
195 class ShenandoahPhaseTimings : public CHeapObj<mtGC> {
196   friend class ShenandoahGCPhase;
197   friend class ShenandoahWorkerTimingsTracker;
198 public:
199 #define SHENANDOAH_PHASE_DECLARE_ENUM(type, title)   type,
200 
201   enum Phase {
202     SHENANDOAH_PHASE_DO(SHENANDOAH_PHASE_DECLARE_ENUM)
203     _num_phases,

242 
243   static const char* phase_name(Phase phase) {
244     assert(phase >= 0 && phase < _num_phases, "Out of bound");
245     return _phase_names[phase];
246   }
247 
248   void print_cycle_on(outputStream* out) const;
249   void print_global_on(outputStream* out) const;
250 };
251 
252 class ShenandoahWorkerTimingsTracker : public StackObj {
253 private:
254   ShenandoahPhaseTimings*          const _timings;
255   ShenandoahPhaseTimings::Phase    const _phase;
256   ShenandoahPhaseTimings::ParPhase const _par_phase;
257   uint const _worker_id;
258 
259   double _start_time;
260   EventGCPhaseParallel _event;
261 public:
262   ShenandoahWorkerTimingsTracker(ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase,
263                                  uint worker_id, bool cumulative = false);
264   ~ShenandoahWorkerTimingsTracker();
265 };
266 
267 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHPHASETIMINGS_HPP
< prev index next >