src/share/vm/gc_implementation/g1/heapRegion.cpp

rev 8912 : Add support for G1HeapRegionTypeChangeEvent

*** 35,44 ****
--- 35,45 ----
  #include "memory/genOopClosures.inline.hpp"
  #include "memory/iterator.hpp"
  #include "memory/space.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/orderAccess.inline.hpp"
+ #include "gc_implementation/g1/heapRegionTracer.hpp"
  
  PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  
  int    HeapRegion::LogOfHRGrainBytes = 0;
  int    HeapRegion::LogOfHRGrainWords = 0;
*** 209,225 ****
--- 210,252 ----
    double region_elapsed_time_ms =
      g1p->predict_region_elapsed_time_ms(this, false /* for_young_gc */);
    _gc_efficiency = (double) reclaimable_bytes() / region_elapsed_time_ms;
  }
  
+ void HeapRegion::set_free() {
+   report_region_type_change(G1HeapRegionTraceType::Free);
+   _type.set_free();
+ }
+ 
+ void HeapRegion::set_eden() {
+   report_region_type_change(G1HeapRegionTraceType::Eden);
+   _type.set_eden();
+ }
+ 
+ void HeapRegion::set_eden_pre_gc() {
+   report_region_type_change(G1HeapRegionTraceType::Eden);
+   _type.set_eden_pre_gc();
+ }
+ 
+ void HeapRegion::set_survivor() {
+   report_region_type_change(G1HeapRegionTraceType::Survivor);
+   _type.set_survivor();
+ }
+ 
+ void HeapRegion::set_old() {
+   report_region_type_change(G1HeapRegionTraceType::Old);
+   _type.set_old();
+ }
+ 
  void HeapRegion::set_startsHumongous(HeapWord* new_top, HeapWord* new_end) {
    assert(!isHumongous(), "sanity / pre-condition");
    assert(end() == _orig_end,
           "Should be normal before the humongous object allocation");
    assert(top() == bottom(), "should be empty");
    assert(bottom() <= new_top && new_top <= new_end, "pre-condition");
  
+   report_region_type_change(G1HeapRegionTraceType::StartsHumongous);
    _type.set_starts_humongous();
    _humongous_start_region = this;
  
    set_end(new_end);
    _offsets.set_for_starts_humongous(new_top);
*** 230,239 ****
--- 257,267 ----
    assert(end() == _orig_end,
           "Should be normal before the humongous object allocation");
    assert(top() == bottom(), "should be empty");
    assert(first_hr->startsHumongous(), "pre-condition");
  
+   report_region_type_change(G1HeapRegionTraceType::ContinuesHumongous);
    _type.set_continues_humongous();
    _humongous_start_region = first_hr;
  }
  
  void HeapRegion::clear_humongous() {
*** 301,310 ****
--- 329,346 ----
    hr_clear(false /*par*/, false /*clear_space*/);
    set_top(bottom());
    record_timestamp();
  }
  
+ void HeapRegion::report_region_type_change(G1HeapRegionTraceType::Type to) {
+   HeapRegionTracer::send_region_type_change(_hrm_index,
+                                             get_trace_type(),
+                                             to,
+                                             (uintptr_t)bottom(),
+                                             used());
+ }
+ 
  CompactibleSpace* HeapRegion::next_compaction_space() const {
    return G1CollectedHeap::heap()->next_compaction_region(this);
  }
  
  void HeapRegion::note_self_forwarding_removal_start(bool during_initial_mark,