src/share/vm/gc_implementation/shared/gcTrace.cpp

Print this page
rev 4873 : 8015972: Refactor the sending of the object count after GC event


   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_implementation/shared/gcHeapSummary.hpp"
  27 #include "gc_implementation/shared/gcTimer.hpp"
  28 #include "gc_implementation/shared/gcTrace.hpp"
  29 #include "gc_implementation/shared/copyFailedInfo.hpp"
  30 #include "memory/heapInspection.hpp"
  31 #include "memory/referenceProcessorStats.hpp"
  32 #include "utilities/globalDefinitions.hpp"
  33 
  34 #if INCLUDE_ALL_GCS
  35 #include "gc_implementation/g1/evacuationInfo.hpp"
  36 #endif
  37 
  38 #define assert_unset_gc_id() assert(_shared_gc_info.id() == SharedGCInfo::UNSET_GCID, "GC already started?")
  39 #define assert_set_gc_id() assert(_shared_gc_info.id() != SharedGCInfo::UNSET_GCID, "GC not started?")
  40 
  41 static jlong GCTracer_next_gc_id = 0;
  42 static GCId create_new_gc_id() {
  43   return GCTracer_next_gc_id++;
  44 }
  45 
  46 void GCTracer::report_gc_start_impl(GCCause::Cause cause, jlong timestamp) {
  47   assert_unset_gc_id();
  48 
  49   GCId gc_id = create_new_gc_id();


  74 }
  75 
  76 void GCTracer::report_gc_end(jlong timestamp, TimePartitions* time_partitions) {
  77   assert_set_gc_id();
  78 
  79   report_gc_end_impl(timestamp, time_partitions);
  80 
  81   _shared_gc_info.set_id(SharedGCInfo::UNSET_GCID);
  82 }
  83 
  84 void GCTracer::report_gc_reference_stats(const ReferenceProcessorStats& rps) const {
  85   assert_set_gc_id();
  86 
  87   send_reference_stats_event(REF_SOFT, rps.soft_count());
  88   send_reference_stats_event(REF_WEAK, rps.weak_count());
  89   send_reference_stats_event(REF_FINAL, rps.final_count());
  90   send_reference_stats_event(REF_PHANTOM, rps.phantom_count());
  91 }
  92 
  93 #if INCLUDE_SERVICES
  94 void ObjectCountEventSenderClosure::do_cinfo(KlassInfoEntry* entry) {












  95   if (should_send_event(entry)) {
  96     send_event(entry);

  97   }
  98 }
  99 
 100 void ObjectCountEventSenderClosure::send_event(KlassInfoEntry* entry) {
 101   _gc_tracer->send_object_count_after_gc_event(entry->klass(), entry->count(),
 102                                                entry->words() * BytesPerWord);
 103 }
 104 
 105 bool ObjectCountEventSenderClosure::should_send_event(KlassInfoEntry* entry) const {

 106   double percentage_of_heap = ((double) entry->words()) / _total_size_in_words;
 107   return percentage_of_heap > _size_threshold_percentage;
 108 }

 109 
 110 void GCTracer::report_object_count_after_gc(BoolObjectClosure* is_alive_cl) {
 111   assert_set_gc_id();

 112 
 113   if (should_send_object_count_after_gc_event()) {
 114     ResourceMark rm;
 115 
 116     KlassInfoTable cit(false);
 117     if (!cit.allocation_failed()) {
 118       HeapInspection hi(false, false, false, NULL);
 119       hi.populate_table(&cit, is_alive_cl);
 120 
 121       ObjectCountEventSenderClosure event_sender(this, cit.size_of_instances_in_words());
 122       cit.iterate(&event_sender);
 123     }
 124   }
 125 }
 126 #endif
 127 
 128 void GCTracer::report_gc_heap_summary(GCWhen::Type when, const GCHeapSummary& heap_summary, const MetaspaceSummary& meta_space_summary) const {
 129   assert_set_gc_id();
 130 
 131   send_gc_heap_summary_event(when, heap_summary);
 132   send_meta_space_summary_event(when, meta_space_summary);
 133 }
 134 
 135 void YoungGCTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
 136   assert_set_gc_id();
 137   assert(_tenuring_threshold != UNSET_TENURING_THRESHOLD, "Tenuring threshold has not been reported");
 138 
 139   GCTracer::report_gc_end_impl(timestamp, time_partitions);
 140   send_young_gc_event();
 141 
 142   _tenuring_threshold = UNSET_TENURING_THRESHOLD;
 143 }
 144 
 145 void YoungGCTracer::report_promotion_failed(const PromotionFailedInfo& pf_info) {
 146   assert_set_gc_id();




   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_implementation/shared/copyFailedInfo.hpp"
  27 #include "gc_implementation/shared/gcHeapSummary.hpp"
  28 #include "gc_implementation/shared/gcTimer.hpp"
  29 #include "gc_implementation/shared/gcTrace.hpp"
  30 #include "gc_implementation/shared/objectCountEventSender.hpp"
  31 #include "memory/heapInspection.hpp"
  32 #include "memory/referenceProcessorStats.hpp"
  33 #include "utilities/globalDefinitions.hpp"
  34 
  35 #if INCLUDE_ALL_GCS
  36 #include "gc_implementation/g1/evacuationInfo.hpp"
  37 #endif
  38 
  39 #define assert_unset_gc_id() assert(_shared_gc_info.id() == SharedGCInfo::UNSET_GCID, "GC already started?")
  40 #define assert_set_gc_id() assert(_shared_gc_info.id() != SharedGCInfo::UNSET_GCID, "GC not started?")
  41 
  42 static jlong GCTracer_next_gc_id = 0;
  43 static GCId create_new_gc_id() {
  44   return GCTracer_next_gc_id++;
  45 }
  46 
  47 void GCTracer::report_gc_start_impl(GCCause::Cause cause, jlong timestamp) {
  48   assert_unset_gc_id();
  49 
  50   GCId gc_id = create_new_gc_id();


  75 }
  76 
  77 void GCTracer::report_gc_end(jlong timestamp, TimePartitions* time_partitions) {
  78   assert_set_gc_id();
  79 
  80   report_gc_end_impl(timestamp, time_partitions);
  81 
  82   _shared_gc_info.set_id(SharedGCInfo::UNSET_GCID);
  83 }
  84 
  85 void GCTracer::report_gc_reference_stats(const ReferenceProcessorStats& rps) const {
  86   assert_set_gc_id();
  87 
  88   send_reference_stats_event(REF_SOFT, rps.soft_count());
  89   send_reference_stats_event(REF_WEAK, rps.weak_count());
  90   send_reference_stats_event(REF_FINAL, rps.final_count());
  91   send_reference_stats_event(REF_PHANTOM, rps.phantom_count());
  92 }
  93 
  94 #if INCLUDE_SERVICES
  95 class ObjectCountEventSenderClosure : public KlassInfoClosure {
  96   const GCId _gc_id;
  97   const double _size_threshold_percentage;
  98   const size_t _total_size_in_words;
  99 
 100  public:
 101   ObjectCountEventSenderClosure(GCId gc_id, size_t total_size_in_words) :
 102     _gc_id(gc_id),
 103     _size_threshold_percentage(ObjectCountCutOffPercent / 100),
 104     _total_size_in_words(total_size_in_words)
 105   {}
 106 
 107   virtual void do_cinfo(KlassInfoEntry* entry) {
 108     if (should_send_event(entry)) {
 109       ObjectCountEventSender::send(entry, _gc_id);
 110     }
 111   }






 112 
 113  private:
 114   bool should_send_event(const KlassInfoEntry* entry) const {
 115     double percentage_of_heap = ((double) entry->words()) / _total_size_in_words;
 116     return percentage_of_heap >= _size_threshold_percentage;
 117   }
 118 };
 119 
 120 void GCTracer::report_object_count_after_gc(BoolObjectClosure* is_alive_cl) {
 121   assert_set_gc_id();
 122   assert(is_alive_cl != NULL, "Must supply function to check liveness");
 123 
 124   if (ObjectCountEventSender::should_send_event()) {
 125     ResourceMark rm;
 126 
 127     KlassInfoTable cit(false);
 128     if (!cit.allocation_failed()) {
 129       HeapInspection hi(false, false, false, NULL);
 130       hi.populate_table(&cit, is_alive_cl);
 131 
 132       ObjectCountEventSenderClosure event_sender(_shared_gc_info.id(), cit.size_of_instances_in_words());
 133       cit.iterate(&event_sender);
 134     }
 135   }
 136 }
 137 #endif // INCLUDE_SERVICES
 138 
 139 void GCTracer::report_gc_heap_summary(GCWhen::Type when, const GCHeapSummary& heap_summary, const MetaspaceSummary& meta_space_summary) const {
 140   assert_set_gc_id();
 141 
 142   send_gc_heap_summary_event(when, heap_summary);
 143   send_meta_space_summary_event(when, meta_space_summary);
 144 }
 145 
 146 void YoungGCTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
 147   assert_set_gc_id();
 148   assert(_tenuring_threshold != UNSET_TENURING_THRESHOLD, "Tenuring threshold has not been reported");
 149 
 150   GCTracer::report_gc_end_impl(timestamp, time_partitions);
 151   send_young_gc_event();
 152 
 153   _tenuring_threshold = UNSET_TENURING_THRESHOLD;
 154 }
 155 
 156 void YoungGCTracer::report_promotion_failed(const PromotionFailedInfo& pf_info) {
 157   assert_set_gc_id();