src/share/vm/gc/g1/g1CollectedHeap.hpp

rev 10384 : [mq]: step.00
rev 10385 : [mq]: step.01

*** 71,85 ****
  class G1RemSet;
  class HeapRegionRemSetIterator;
  class G1ConcurrentMark;
  class ConcurrentMarkThread;
  class ConcurrentG1Refine;
- class ConcurrentGCTimer;
  class GenerationCounters;
  class STWGCTimer;
  class G1NewTracer;
- class G1OldTracer;
  class EvacuationFailedInfo;
  class nmethod;
  class Ticks;
  class WorkGang;
  class G1Allocator;
--- 71,83 ----
*** 268,279 ****
  
    // Keeps track of how many "old marking cycles" (i.e., Full GCs or
    // concurrent cycles) we have completed.
    volatile uint _old_marking_cycles_completed;
  
-   bool _heap_summary_sent;
- 
    // This is a non-product method that is helpful for testing. It is
    // called at the end of a GC and artificially expands the heap by
    // allocating a number of dead regions. This way we can induce very
    // frequent marking cycles and stress the cleanup / concurrent
    // cleanup code more (as all the regions that will be allocated by
--- 266,275 ----
*** 620,633 ****
  
    uint old_marking_cycles_completed() {
      return _old_marking_cycles_completed;
    }
  
-   void register_concurrent_cycle_start(const Ticks& start_time);
-   void register_concurrent_cycle_end();
-   void trace_heap_after_concurrent_cycle();
- 
    G1HRPrinter* hr_printer() { return &_hr_printer; }
  
    // Allocates a new heap region instance.
    HeapRegion* new_heap_region(uint hrs_index, MemRegion mr);
  
--- 616,625 ----
*** 898,910 ****
  
    // The (stw) reference processor...
    ReferenceProcessor* _ref_processor_stw;
  
    STWGCTimer* _gc_timer_stw;
-   ConcurrentGCTimer* _gc_timer_cm;
  
-   G1OldTracer* _gc_tracer_cm;
    G1NewTracer* _gc_tracer_stw;
  
    // During reference object discovery, the _is_alive_non_header
    // closure (if non-null) is applied to the referent object to
    // determine whether the referent is live. If so then the
--- 890,900 ----
*** 1034,1046 ****
    G1NewTracer* gc_tracer_stw() const { return _gc_tracer_stw; }
  
    // The Concurrent Marking reference processor...
    ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }
  
-   ConcurrentGCTimer* gc_timer_cm() const { return _gc_timer_cm; }
-   G1OldTracer* gc_tracer_cm() const { return _gc_tracer_cm; }
- 
    virtual size_t capacity() const;
    virtual size_t used() const;
    // This should be called when we're not holding the heap lock. The
    // result might be a bit inaccurate.
    size_t used_unlocked() const;
--- 1024,1033 ----