71 class G1RemSet;

    71 class G1RemSet;

    72 class HeapRegionRemSetIterator;

    72 class HeapRegionRemSetIterator;

    73 class G1ConcurrentMark;

    73 class G1ConcurrentMark;

    74 class ConcurrentMarkThread;

    74 class ConcurrentMarkThread;

    75 class ConcurrentG1Refine;

    75 class ConcurrentG1Refine;

    77 class GenerationCounters;

    76 class GenerationCounters;

    78 class STWGCTimer;

    77 class STWGCTimer;

    79 class G1NewTracer;

    78 class G1NewTracer;

    81 class EvacuationFailedInfo;

    79 class EvacuationFailedInfo;

    82 class nmethod;

    80 class nmethod;

    83 class Ticks;

    81 class Ticks;

    84 class WorkGang;

    82 class WorkGang;

    85 class G1Allocator;

    83 class G1Allocator;

   268 

   266 

   269   // Keeps track of how many "old marking cycles" (i.e., Full GCs or

   267   // Keeps track of how many "old marking cycles" (i.e., Full GCs or

   270   // concurrent cycles) we have completed.

   268   // concurrent cycles) we have completed.

   271   volatile uint _old_marking_cycles_completed;

   269   volatile uint _old_marking_cycles_completed;

   272 

   270 

   275   // This is a non-product method that is helpful for testing. It is

   271   // This is a non-product method that is helpful for testing. It is

   276   // called at the end of a GC and artificially expands the heap by

   272   // called at the end of a GC and artificially expands the heap by

   277   // allocating a number of dead regions. This way we can induce very

   273   // allocating a number of dead regions. This way we can induce very

   278   // frequent marking cycles and stress the cleanup / concurrent

   274   // frequent marking cycles and stress the cleanup / concurrent

   279   // cleanup code more (as all the regions that will be allocated by

   275   // cleanup code more (as all the regions that will be allocated by

   620 

   616 

   621   uint old_marking_cycles_completed() {

   617   uint old_marking_cycles_completed() {

   622     return _old_marking_cycles_completed;

   618     return _old_marking_cycles_completed;

   623   }

   619   }

   624 

   620 

   629   G1HRPrinter* hr_printer() { return &_hr_printer; }

   621   G1HRPrinter* hr_printer() { return &_hr_printer; }

   630 

   622 

   631   // Allocates a new heap region instance.

   623   // Allocates a new heap region instance.

   632   HeapRegion* new_heap_region(uint hrs_index, MemRegion mr);

   624   HeapRegion* new_heap_region(uint hrs_index, MemRegion mr);

   633 

   625 

   898 

   890 

   899   // The (stw) reference processor...

   891   // The (stw) reference processor...

   900   ReferenceProcessor* _ref_processor_stw;

   892   ReferenceProcessor* _ref_processor_stw;

   901 

   893 

   902   STWGCTimer* _gc_timer_stw;

   894   STWGCTimer* _gc_timer_stw;

   906   G1NewTracer* _gc_tracer_stw;

   896   G1NewTracer* _gc_tracer_stw;

   907 

   897 

   908   // During reference object discovery, the _is_alive_non_header

   898   // During reference object discovery, the _is_alive_non_header

   909   // closure (if non-null) is applied to the referent object to

   899   // closure (if non-null) is applied to the referent object to

   910   // determine whether the referent is live. If so then the

   900   // determine whether the referent is live. If so then the

  1033 

  1023 

  1034   G1NewTracer* gc_tracer_stw() const { return _gc_tracer_stw; }

  1024   G1NewTracer* gc_tracer_stw() const { return _gc_tracer_stw; }

  1035 

  1025 

  1036   // The Concurrent Marking reference processor...

  1026   // The Concurrent Marking reference processor...

  1037   ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }

  1027   ReferenceProcessor* ref_processor_cm() const { return _ref_processor_cm; }

  1041 

  1028 

  1042   virtual size_t capacity() const;

  1029   virtual size_t capacity() const;

  1043   virtual size_t used() const;

  1030   virtual size_t used() const;

  1044   // This should be called when we're not holding the heap lock. The

  1031   // This should be called when we're not holding the heap lock. The

  1045   // result might be a bit inaccurate.

  1032   // result might be a bit inaccurate.