--- old/src/share/vm/gc_implementation/shared/gcTrace.cpp
          +++ new/src/share/vm/gc_implementation/shared/gcTrace.cpp

   1    1  /*
   2    2   * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
  13   13   * accompanied this code).
  14   14   *
  15   15   * You should have received a copy of the GNU General Public License version
  16   16   * 2 along with this work; if not, write to the Free Software Foundation,
  17   17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18   18   *
  19   19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20   20   * or visit www.oracle.com if you need additional information or have any
  21   21   * questions.
  22   22   *
  23   23   */
  24   24  
  25   25  #include "precompiled.hpp"
  26   26  #include "gc_implementation/shared/gcHeapSummary.hpp"
  27   27  #include "gc_implementation/shared/gcTimer.hpp"
  28   28  #include "gc_implementation/shared/gcTrace.hpp"
  29   29  #include "gc_implementation/shared/copyFailedInfo.hpp"
  30   30  #include "memory/heapInspection.hpp"
  31   31  #include "memory/iterator.hpp"
  32   32  #include "memory/referenceProcessorStats.hpp"
  33   33  #include "utilities/globalDefinitions.hpp"
  34   34  
  35   35  #ifndef SERIALGC
  36   36  #include "gc_implementation/g1/evacuationInfo.hpp"
  37   37  #endif
  38   38  
  39   39  #define assert_unset_gc_id() assert(_shared_gc_info.id() == SharedGCInfo::UNSET_GCID, "GC already started?")
  40   40  #define assert_set_gc_id() assert(_shared_gc_info.id() != SharedGCInfo::UNSET_GCID, "GC not started?")
  41   41  
  42   42  static jlong GCTracer_next_gc_id = 0;
  43   43  static GCId create_new_gc_id() {
  44   44    return GCTracer_next_gc_id++;
  45   45  }
  46   46  
  47   47  void GCTracer::report_gc_start_impl(GCCause::Cause cause, jlong timestamp) {
  48   48    assert_unset_gc_id();
  49   49  
  50   50    GCId gc_id = create_new_gc_id();
  51   51    _shared_gc_info.set_id(gc_id);
  52   52    _shared_gc_info.set_cause(cause);
  53   53    _shared_gc_info.set_start_timestamp(timestamp);
  54   54  }
  55   55  
  56   56  void GCTracer::report_gc_start(GCCause::Cause cause, jlong timestamp) {
  57   57    assert_unset_gc_id();
  58   58  
  59   59    report_gc_start_impl(cause, timestamp);
  60   60  }
  61   61  
  62   62  bool GCTracer::has_reported_gc_start() const {
  63   63    return _shared_gc_info.id() != SharedGCInfo::UNSET_GCID;
  64   64  }
  65   65  
  66   66  void GCTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
  67   67    assert_set_gc_id();
  68   68  
  69   69    _shared_gc_info.set_sum_of_pauses(time_partitions->sum_of_pauses());
  70   70    _shared_gc_info.set_longest_pause(time_partitions->longest_pause());
  71   71    _shared_gc_info.set_end_timestamp(timestamp);
  72   72  
  73   73    send_phase_events(time_partitions);
  74   74    send_garbage_collection_event();
  75   75  }
  76   76  
  77   77  void GCTracer::report_gc_end(jlong timestamp, TimePartitions* time_partitions) {
  78   78    assert_set_gc_id();
  79   79  
  80   80    report_gc_end_impl(timestamp, time_partitions);
  81   81  
  82   82    _shared_gc_info.set_id(SharedGCInfo::UNSET_GCID);
  83   83  }
  84   84  
  85   85  void GCTracer::report_gc_reference_stats(const ReferenceProcessorStats& rps) const {
  86   86    assert_set_gc_id();
  87   87  
  88   88    send_reference_stats_event(REF_SOFT, rps.soft_count());
  89   89    send_reference_stats_event(REF_WEAK, rps.weak_count());

  90   90    send_reference_stats_event(REF_FINAL, rps.final_count());
  91   91    send_reference_stats_event(REF_PHANTOM, rps.phantom_count());
  92   92  }
  93   93  
  94   94  class ObjectCountEventSenderClosure : public KlassInfoClosure {
  95   95    GCTracer* _gc_tracer;
  96   96   public:
  97   97    ObjectCountEventSenderClosure(GCTracer* gc_tracer) : _gc_tracer(gc_tracer) {}
  98   98   private:
  99   99    void do_cinfo(KlassInfoEntry* entry) {
 100      -    _gc_tracer->send_object_count_after_gc_event(entry->klass(), entry->count(),
 101      -                                                 entry->words() * BytesPerWord);
      100 +    if (is_visible_klass(entry->klass())) {
      101 +      _gc_tracer->send_object_count_after_gc_event(entry->klass(), entry->count(),
      102 +                                                   entry->words() * BytesPerWord);
      103 +      }
 102  104    }
      105 +
      106 +  // Do not expose internal implementation specific classes
      107 +  bool is_visible_klass(klassOop k) {
      108 +    return k->klass_part()->oop_is_instance() ||
      109 +           (k->klass_part()->oop_is_array() && k != Universe::systemObjArrayKlassObj());
      110 +  }
 103  111  };
 104  112  
 105  113  void GCTracer::report_object_count_after_gc(BoolObjectClosure *is_alive_cl) {
 106  114    if (should_send_object_count_after_gc_event()) {
 107  115      ResourceMark rm;
 108  116  
 109  117      KlassInfoTable cit(HeapInspection::start_of_perm_gen());
 110  118      if (!cit.allocation_failed()) {
 111  119        ObjectCountEventSenderClosure event_sender(this);
 112  120        HeapInspection::instance_inspection(&cit, &event_sender, false, is_alive_cl);

 113  121      }
 114  122    }
 115  123  }
 116  124  
 117  125  void GCTracer::report_gc_heap_summary(GCWhen::Type when, const GCHeapSummary& heap_summary, const PermGenSummary& perm_gen_summary) const {
 118  126    assert_set_gc_id();
 119  127  
 120  128    send_gc_heap_summary_event(when, heap_summary);
 121  129    send_perm_gen_summary_event(when, perm_gen_summary);
 122  130  }
 123  131  
 124  132  void YoungGCTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
 125  133    assert_set_gc_id();
 126  134    assert(_tenuring_threshold != UNSET_TENURING_THRESHOLD, "Tenuring threshold has not been reported");
 127  135  
 128  136    GCTracer::report_gc_end_impl(timestamp, time_partitions);
 129  137    send_young_gc_event();
 130  138  
 131  139    _tenuring_threshold = UNSET_TENURING_THRESHOLD;
 132  140  }
 133  141  
 134  142  void YoungGCTracer::report_promotion_failed(const PromotionFailedInfo& pf_info) {
 135  143    assert_set_gc_id();
 136  144  
 137  145    send_promotion_failed_event(pf_info);
 138  146  }
 139  147  
 140  148  void YoungGCTracer::report_tenuring_threshold(const uint tenuring_threshold) {
 141  149    _tenuring_threshold = tenuring_threshold;
 142  150  }
 143  151  
 144  152  void OldGCTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
 145  153    assert_set_gc_id();
 146  154  
 147  155    GCTracer::report_gc_end_impl(timestamp, time_partitions);
 148  156    send_old_gc_event();
 149  157  }
 150  158  
 151  159  void ParallelOldTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
 152  160    assert_set_gc_id();
 153  161  
 154  162    OldGCTracer::report_gc_end_impl(timestamp, time_partitions);
 155  163    send_parallel_old_event();
 156  164  }
 157  165  
 158  166  void ParallelOldTracer::report_dense_prefix(void* dense_prefix) {
 159  167    assert_set_gc_id();
 160  168  
 161  169    _parallel_old_gc_info.report_dense_prefix(dense_prefix);
 162  170  }
 163  171  
 164  172  void OldGCTracer::report_concurrent_mode_failure() {
 165  173    assert_set_gc_id();
 166  174  
 167  175    send_concurrent_mode_failure_event();
 168  176  }
 169  177  
 170  178  #ifndef SERIALGC
 171  179  void G1NewTracer::report_yc_type(G1YCType type) {
 172  180    assert_set_gc_id();
 173  181  
 174  182    _g1_young_gc_info.set_type(type);
 175  183  }
 176  184  
 177  185  void G1NewTracer::report_gc_end_impl(jlong timestamp, TimePartitions* time_partitions) {
 178  186    assert_set_gc_id();
 179  187  
 180  188    YoungGCTracer::report_gc_end_impl(timestamp, time_partitions);
 181  189    send_g1_young_gc_event();
 182  190  }
 183  191  
 184  192  void G1NewTracer::report_evacuation_info(EvacuationInfo* info) {
 185  193    assert_set_gc_id();
 186  194  
 187  195    send_evacuation_info_event(info);
 188  196  }
 189  197  
 190  198  void G1NewTracer::report_evacuation_failed(EvacuationFailedInfo& ef_info) {
 191  199    assert_set_gc_id();
 192  200  
 193  201    send_evacuation_failed_event(ef_info);
 194  202    ef_info.reset();
 195  203  }
 196  204  #endif

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX