48 #include "gc/shared/collectedHeap.hpp"

    48 #include "gc/shared/collectedHeap.hpp"

    49 #include "gc/shared/gcHeapSummary.hpp"

    49 #include "gc/shared/gcHeapSummary.hpp"

    50 #include "gc/shared/plab.hpp"

    50 #include "gc/shared/plab.hpp"

    51 #include "gc/shared/preservedMarks.hpp"

    51 #include "gc/shared/preservedMarks.hpp"

    52 #include "memory/memRegion.hpp"

    52 #include "memory/memRegion.hpp"

    53 #include "utilities/stack.hpp"

    54 #include "utilities/stack.hpp"

    54 

    55 

    55 // A "G1CollectedHeap" is an implementation of a java heap for HotSpot.

    56 // A "G1CollectedHeap" is an implementation of a java heap for HotSpot.

    56 // It uses the "Garbage First" heap organization and algorithm, which

    57 // It uses the "Garbage First" heap organization and algorithm, which

    57 // may combine concurrent marking with parallel, incremental compaction of

    58 // may combine concurrent marking with parallel, incremental compaction of

    62 class HRRSCleanupTask;

    63 class HRRSCleanupTask;

    63 class GenerationSpec;

    64 class GenerationSpec;

    64 class G1ParScanThreadState;

    65 class G1ParScanThreadState;

    65 class G1ParScanThreadStateSet;

    66 class G1ParScanThreadStateSet;

    66 class G1ParScanThreadState;

    67 class G1ParScanThreadState;

    67 class ObjectClosure;

    69 class ObjectClosure;

    68 class SpaceClosure;

    70 class SpaceClosure;

    69 class CompactibleSpaceClosure;

    71 class CompactibleSpaceClosure;

    70 class Space;

    72 class Space;

    71 class G1CollectionSet;

    73 class G1CollectionSet;

   147   G1YoungRemSetSamplingThread* _young_gen_sampling_thread;

   149   G1YoungRemSetSamplingThread* _young_gen_sampling_thread;

   148 

   150 

   149   WorkGang* _workers;

   151   WorkGang* _workers;

   150   G1CollectorPolicy* _collector_policy;

   152   G1CollectorPolicy* _collector_policy;

   151 

   153 

   152   static size_t _humongous_object_threshold_in_words;

   161   static size_t _humongous_object_threshold_in_words;

   153 

   162 

   154   // The secondary free list which contains regions that have been

   163   // The secondary free list which contains regions that have been

   155   // freed up during the cleanup process. This will be appended to

   164   // freed up during the cleanup process. This will be appended to

   156   // the master free list when appropriate.

   165   // the master free list when appropriate.

   159   // It keeps track of the old regions.

   168   // It keeps track of the old regions.

   160   HeapRegionSet _old_set;

   169   HeapRegionSet _old_set;

   161 

   170 

   162   // It keeps track of the humongous regions.

   171   // It keeps track of the humongous regions.

   163   HeapRegionSet _humongous_set;

   172   HeapRegionSet _humongous_set;

   164 

   175 

   165   void eagerly_reclaim_humongous_regions();

   176   void eagerly_reclaim_humongous_regions();

   166   // Start a new incremental collection set for the next pause.

   177   // Start a new incremental collection set for the next pause.

   167   void start_new_collection_set();

   178   void start_new_collection_set();

   168 

   179 

  1004   virtual CollectorPolicy* collector_policy() const;

  1015   virtual CollectorPolicy* collector_policy() const;

  1005 

  1016 

  1006   // Adaptive size policy.  No such thing for g1.

  1017   // Adaptive size policy.  No such thing for g1.

  1007   virtual AdaptiveSizePolicy* size_policy() { return NULL; }

  1018   virtual AdaptiveSizePolicy* size_policy() { return NULL; }

  1008 

  1019 

  1009   // The rem set and barrier set.

  1023   // The rem set and barrier set.

  1010   G1RemSet* g1_rem_set() const { return _g1_rem_set; }

  1024   G1RemSet* g1_rem_set() const { return _g1_rem_set; }

  1011 

  1025 

  1012   // Try to minimize the remembered set.

  1026   // Try to minimize the remembered set.

  1013   void scrub_rem_set();

  1027   void scrub_rem_set();