rev 9314 : imported patch 8136679-jfr-event-for-dynamic-ihop
rev 9315 : imported patch sangheon-review

   1 /*
   2  * Copyright (c) 2012, 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 #include "precompiled.hpp"
  26 #include "gc/shared/copyFailedInfo.hpp"
  27 #include "gc/shared/gcHeapSummary.hpp"
  28 #include "gc/shared/gcTimer.hpp"
  29 #include "gc/shared/gcTrace.hpp"
  30 #include "gc/shared/gcWhen.hpp"
  31 #include "runtime/os.hpp"
  32 #include "trace/traceBackend.hpp"
  33 #include "trace/tracing.hpp"
  34 #include "utilities/macros.hpp"
  35 #if INCLUDE_ALL_GCS
  36 #include "gc/g1/evacuationInfo.hpp"
  37 #include "gc/g1/g1YCTypes.hpp"

  38 #endif
  39 
  40 // All GC dependencies against the trace framework is contained within this file.
  41 
  42 typedef uintptr_t TraceAddress;
  43 
  44 void GCTracer::send_garbage_collection_event() const {
  45   EventGCGarbageCollection event(UNTIMED);
  46   if (event.should_commit()) {
  47     event.set_gcId(GCId::current());
  48     event.set_name(_shared_gc_info.name());
  49     event.set_cause((u2) _shared_gc_info.cause());
  50     event.set_sumOfPauses(_shared_gc_info.sum_of_pauses());
  51     event.set_longestPause(_shared_gc_info.longest_pause());
  52     event.set_starttime(_shared_gc_info.start_timestamp());
  53     event.set_endtime(_shared_gc_info.end_timestamp());
  54     event.commit();
  55   }
  56 }
  57 
  58 void GCTracer::send_reference_stats_event(ReferenceType type, size_t count) const {
  59   EventGCReferenceStatistics e;
  60   if (e.should_commit()) {
  61       e.set_gcId(GCId::current());
  62       e.set_type((u1)type);
  63       e.set_count(count);
  64       e.commit();
  65   }
  66 }
  67 
  68 void GCTracer::send_metaspace_chunk_free_list_summary(GCWhen::Type when, Metaspace::MetadataType mdtype,
  69                                                       const MetaspaceChunkFreeListSummary& summary) const {
  70   EventMetaspaceChunkFreeListSummary e;
  71   if (e.should_commit()) {
  72     e.set_gcId(GCId::current());
  73     e.set_when(when);
  74     e.set_metadataType(mdtype);
  75 
  76     e.set_specializedChunks(summary.num_specialized_chunks());
  77     e.set_specializedChunksTotalSize(summary.specialized_chunks_size_in_bytes());
  78 
  79     e.set_smallChunks(summary.num_small_chunks());
  80     e.set_smallChunksTotalSize(summary.small_chunks_size_in_bytes());
  81 
  82     e.set_mediumChunks(summary.num_medium_chunks());
  83     e.set_mediumChunksTotalSize(summary.medium_chunks_size_in_bytes());
  84 
  85     e.set_humongousChunks(summary.num_humongous_chunks());
  86     e.set_humongousChunksTotalSize(summary.humongous_chunks_size_in_bytes());
  87 
  88     e.commit();
  89   }
  90 }
  91 
  92 void ParallelOldTracer::send_parallel_old_event() const {
  93   EventGCParallelOld e(UNTIMED);
  94   if (e.should_commit()) {
  95     e.set_gcId(GCId::current());
  96     e.set_densePrefix((TraceAddress)_parallel_old_gc_info.dense_prefix());
  97     e.set_starttime(_shared_gc_info.start_timestamp());
  98     e.set_endtime(_shared_gc_info.end_timestamp());
  99     e.commit();
 100   }
 101 }
 102 
 103 void YoungGCTracer::send_young_gc_event() const {
 104   EventGCYoungGarbageCollection e(UNTIMED);
 105   if (e.should_commit()) {
 106     e.set_gcId(GCId::current());
 107     e.set_tenuringThreshold(_tenuring_threshold);
 108     e.set_starttime(_shared_gc_info.start_timestamp());
 109     e.set_endtime(_shared_gc_info.end_timestamp());
 110     e.commit();
 111   }
 112 }
 113 
 114 bool YoungGCTracer::should_send_promotion_in_new_plab_event() const {
 115   return EventPromoteObjectInNewPLAB::is_enabled();
 116 }
 117 
 118 bool YoungGCTracer::should_send_promotion_outside_plab_event() const {
 119   return EventPromoteObjectOutsidePLAB::is_enabled();
 120 }
 121 
 122 void YoungGCTracer::send_promotion_in_new_plab_event(Klass* klass, size_t obj_size,
 123                                                      uint age, bool tenured,
 124                                                      size_t plab_size) const {
 125 
 126   EventPromoteObjectInNewPLAB event;
 127   if (event.should_commit()) {
 128     event.set_gcId(GCId::current());
 129     event.set_class(klass);
 130     event.set_objectSize(obj_size);
 131     event.set_tenured(tenured);
 132     event.set_tenuringAge(age);
 133     event.set_plabSize(plab_size);
 134     event.commit();
 135   }
 136 }
 137 
 138 void YoungGCTracer::send_promotion_outside_plab_event(Klass* klass, size_t obj_size,
 139                                                       uint age, bool tenured) const {
 140 
 141   EventPromoteObjectOutsidePLAB event;
 142   if (event.should_commit()) {
 143     event.set_gcId(GCId::current());
 144     event.set_class(klass);
 145     event.set_objectSize(obj_size);
 146     event.set_tenured(tenured);
 147     event.set_tenuringAge(age);
 148     event.commit();
 149   }
 150 }
 151 
 152 void OldGCTracer::send_old_gc_event() const {
 153   EventGCOldGarbageCollection e(UNTIMED);
 154   if (e.should_commit()) {
 155     e.set_gcId(GCId::current());
 156     e.set_starttime(_shared_gc_info.start_timestamp());
 157     e.set_endtime(_shared_gc_info.end_timestamp());
 158     e.commit();
 159   }
 160 }
 161 
 162 static TraceStructCopyFailed to_trace_struct(const CopyFailedInfo& cf_info) {
 163   TraceStructCopyFailed failed_info;
 164   failed_info.set_objectCount(cf_info.failed_count());
 165   failed_info.set_firstSize(cf_info.first_size());
 166   failed_info.set_smallestSize(cf_info.smallest_size());
 167   failed_info.set_totalSize(cf_info.total_size());
 168   return failed_info;
 169 }
 170 
 171 void YoungGCTracer::send_promotion_failed_event(const PromotionFailedInfo& pf_info) const {
 172   EventPromotionFailed e;
 173   if (e.should_commit()) {
 174     e.set_gcId(GCId::current());
 175     e.set_data(to_trace_struct(pf_info));
 176     e.set_thread(pf_info.thread()->thread_id());
 177     e.commit();
 178   }
 179 }
 180 
 181 // Common to CMS and G1
 182 void OldGCTracer::send_concurrent_mode_failure_event() {
 183   EventConcurrentModeFailure e;
 184   if (e.should_commit()) {
 185     e.set_gcId(GCId::current());
 186     e.commit();
 187   }
 188 }
 189 
 190 #if INCLUDE_ALL_GCS
 191 void G1NewTracer::send_g1_young_gc_event() {
 192   EventGCG1GarbageCollection e(UNTIMED);
 193   if (e.should_commit()) {
 194     e.set_gcId(GCId::current());
 195     e.set_type(_g1_young_gc_info.type());
 196     e.set_starttime(_shared_gc_info.start_timestamp());
 197     e.set_endtime(_shared_gc_info.end_timestamp());
 198     e.commit();
 199   }
 200 }
 201 
 202 void G1MMUTracer::send_g1_mmu_event(double timeSlice, double gcTime, double maxTime) {
 203   EventGCG1MMU e;
 204   if (e.should_commit()) {
 205     e.set_gcId(GCId::current());
 206     e.set_timeSlice(timeSlice);
 207     e.set_gcTime(gcTime);
 208     e.set_maxGcTime(maxTime);
 209     e.commit();
 210   }
 211 }
 212 
 213 void G1NewTracer::send_evacuation_info_event(EvacuationInfo* info) {
 214   EventEvacuationInfo e;
 215   if (e.should_commit()) {
 216     e.set_gcId(GCId::current());
 217     e.set_cSetRegions(info->collectionset_regions());
 218     e.set_cSetUsedBefore(info->collectionset_used_before());
 219     e.set_cSetUsedAfter(info->collectionset_used_after());
 220     e.set_allocationRegions(info->allocation_regions());
 221     e.set_allocRegionsUsedBefore(info->alloc_regions_used_before());
 222     e.set_allocRegionsUsedAfter(info->alloc_regions_used_before() + info->bytes_copied());
 223     e.set_bytesCopied(info->bytes_copied());
 224     e.set_regionsFreed(info->regions_freed());
 225     e.commit();
 226   }
 227 }
 228 
 229 void G1NewTracer::send_evacuation_failed_event(const EvacuationFailedInfo& ef_info) const {
 230   EventEvacuationFailed e;
 231   if (e.should_commit()) {
 232     e.set_gcId(GCId::current());
 233     e.set_data(to_trace_struct(ef_info));
 234     e.commit();
 235   }
 236 }
 237 
 238 static TraceStructG1EvacStats create_g1_evacstats(unsigned gcid, const G1EvacSummary& summary) {
 239   TraceStructG1EvacStats s;
 240   s.set_gcId(gcid);
 241   s.set_allocated(summary.allocated() * HeapWordSize);
 242   s.set_wasted(summary.wasted() * HeapWordSize);
 243   s.set_used(summary.used() * HeapWordSize);
 244   s.set_undoWaste(summary.undo_wasted() * HeapWordSize);
 245   s.set_regionEndWaste(summary.region_end_waste() * HeapWordSize);
 246   s.set_regionsRefilled(summary.regions_filled());
 247   s.set_directAllocated(summary.direct_allocated() * HeapWordSize);
 248   s.set_failureUsed(summary.failure_used() * HeapWordSize);
 249   s.set_failureWaste(summary.failure_waste() * HeapWordSize);
 250   return s;
 251 }
 252 
 253 void G1NewTracer::send_young_evacuation_statistics(const G1EvacSummary& summary) const {
 254   EventGCG1EvacuationYoungStatistics surv_evt;
 255   if (surv_evt.should_commit()) {
 256     surv_evt.set_stats(create_g1_evacstats(GCId::current(), summary));
 257     surv_evt.commit();
 258   }
 259 }
 260 
 261 void G1NewTracer::send_old_evacuation_statistics(const G1EvacSummary& summary) const {
 262   EventGCG1EvacuationOldStatistics old_evt;
 263   if (old_evt.should_commit()) {
 264     old_evt.set_stats(create_g1_evacstats(GCId::current(), summary));
 265     old_evt.commit();
 266   }
 267 }





































 268 #endif
 269 
 270 static TraceStructVirtualSpace to_trace_struct(const VirtualSpaceSummary& summary) {
 271   TraceStructVirtualSpace space;
 272   space.set_start((TraceAddress)summary.start());
 273   space.set_committedEnd((TraceAddress)summary.committed_end());
 274   space.set_committedSize(summary.committed_size());
 275   space.set_reservedEnd((TraceAddress)summary.reserved_end());
 276   space.set_reservedSize(summary.reserved_size());
 277   return space;
 278 }
 279 
 280 static TraceStructObjectSpace to_trace_struct(const SpaceSummary& summary) {
 281   TraceStructObjectSpace space;
 282   space.set_start((TraceAddress)summary.start());
 283   space.set_end((TraceAddress)summary.end());
 284   space.set_used(summary.used());
 285   space.set_size(summary.size());
 286   return space;
 287 }
 288 
 289 class GCHeapSummaryEventSender : public GCHeapSummaryVisitor {
 290   GCWhen::Type _when;
 291  public:
 292   GCHeapSummaryEventSender(GCWhen::Type when) : _when(when) {}
 293 
 294   void visit(const GCHeapSummary* heap_summary) const {
 295     const VirtualSpaceSummary& heap_space = heap_summary->heap();
 296 
 297     EventGCHeapSummary e;
 298     if (e.should_commit()) {
 299       e.set_gcId(GCId::current());
 300       e.set_when((u1)_when);
 301       e.set_heapSpace(to_trace_struct(heap_space));
 302       e.set_heapUsed(heap_summary->used());
 303       e.commit();
 304     }
 305   }
 306 
 307   void visit(const G1HeapSummary* g1_heap_summary) const {
 308     visit((GCHeapSummary*)g1_heap_summary);
 309 
 310     EventG1HeapSummary e;
 311     if (e.should_commit()) {
 312       e.set_gcId(GCId::current());
 313       e.set_when((u1)_when);
 314       e.set_edenUsedSize(g1_heap_summary->edenUsed());
 315       e.set_edenTotalSize(g1_heap_summary->edenCapacity());
 316       e.set_survivorUsedSize(g1_heap_summary->survivorUsed());
 317       e.commit();
 318     }
 319   }
 320 
 321   void visit(const PSHeapSummary* ps_heap_summary) const {
 322     visit((GCHeapSummary*)ps_heap_summary);
 323 
 324     const VirtualSpaceSummary& old_summary = ps_heap_summary->old();
 325     const SpaceSummary& old_space = ps_heap_summary->old_space();
 326     const VirtualSpaceSummary& young_summary = ps_heap_summary->young();
 327     const SpaceSummary& eden_space = ps_heap_summary->eden();
 328     const SpaceSummary& from_space = ps_heap_summary->from();
 329     const SpaceSummary& to_space = ps_heap_summary->to();
 330 
 331     EventPSHeapSummary e;
 332     if (e.should_commit()) {
 333       e.set_gcId(GCId::current());
 334       e.set_when((u1)_when);
 335 
 336       e.set_oldSpace(to_trace_struct(ps_heap_summary->old()));
 337       e.set_oldObjectSpace(to_trace_struct(ps_heap_summary->old_space()));
 338       e.set_youngSpace(to_trace_struct(ps_heap_summary->young()));
 339       e.set_edenSpace(to_trace_struct(ps_heap_summary->eden()));
 340       e.set_fromSpace(to_trace_struct(ps_heap_summary->from()));
 341       e.set_toSpace(to_trace_struct(ps_heap_summary->to()));
 342       e.commit();
 343     }
 344   }
 345 };
 346 
 347 void GCTracer::send_gc_heap_summary_event(GCWhen::Type when, const GCHeapSummary& heap_summary) const {
 348   GCHeapSummaryEventSender visitor(when);
 349   heap_summary.accept(&visitor);
 350 }
 351 
 352 static TraceStructMetaspaceSizes to_trace_struct(const MetaspaceSizes& sizes) {
 353   TraceStructMetaspaceSizes meta_sizes;
 354 
 355   meta_sizes.set_committed(sizes.committed());
 356   meta_sizes.set_used(sizes.used());
 357   meta_sizes.set_reserved(sizes.reserved());
 358 
 359   return meta_sizes;
 360 }
 361 
 362 void GCTracer::send_meta_space_summary_event(GCWhen::Type when, const MetaspaceSummary& meta_space_summary) const {
 363   EventMetaspaceSummary e;
 364   if (e.should_commit()) {
 365     e.set_gcId(GCId::current());
 366     e.set_when((u1) when);
 367     e.set_gcThreshold(meta_space_summary.capacity_until_GC());
 368     e.set_metaspace(to_trace_struct(meta_space_summary.meta_space()));
 369     e.set_dataSpace(to_trace_struct(meta_space_summary.data_space()));
 370     e.set_classSpace(to_trace_struct(meta_space_summary.class_space()));
 371     e.commit();
 372   }
 373 }
 374 
 375 class PhaseSender : public PhaseVisitor {
 376  public:
 377   template<typename T>
 378   void send_phase(PausePhase* pause) {
 379     T event(UNTIMED);
 380     if (event.should_commit()) {
 381       event.set_gcId(GCId::current());
 382       event.set_name(pause->name());
 383       event.set_starttime(pause->start());
 384       event.set_endtime(pause->end());
 385       event.commit();
 386     }
 387   }
 388 
 389   void visit(GCPhase* pause) { ShouldNotReachHere(); }
 390   void visit(ConcurrentPhase* pause) { Unimplemented(); }
 391   void visit(PausePhase* pause) {
 392     assert(PhasesStack::PHASE_LEVELS == 5, "Need more event types");
 393 
 394     switch (pause->level()) {
 395       case 0: send_phase<EventGCPhasePause>(pause); break;
 396       case 1: send_phase<EventGCPhasePauseLevel1>(pause); break;
 397       case 2: send_phase<EventGCPhasePauseLevel2>(pause); break;
 398       case 3: send_phase<EventGCPhasePauseLevel3>(pause); break;
 399       default: /* Ignore sending this phase */ break;
 400     }
 401   }
 402 };
 403 
 404 void GCTracer::send_phase_events(TimePartitions* time_partitions) const {
 405   PhaseSender phase_reporter;
 406 
 407   TimePartitionPhasesIterator iter(time_partitions);
 408   while (iter.has_next()) {
 409     GCPhase* phase = iter.next();
 410     phase->accept(&phase_reporter);
 411   }
 412 }
--- EOF ---