29 #include "gc/shared/collectorPolicy.hpp"

    29 #include "gc/shared/collectorPolicy.hpp"

    30 #include "gc/shared/generation.hpp"

    30 #include "gc/shared/generation.hpp"

    31 #include "gc/shared/softRefGenPolicy.hpp"

    31 #include "gc/shared/softRefGenPolicy.hpp"

    32 

    32 

    33 class AdaptiveSizePolicy;

    33 class AdaptiveSizePolicy;

    34 class GenerationSpec;

    35 class GenerationSpec;

    35 class StrongRootsScope;

    36 class StrongRootsScope;

    36 class SubTasksDone;

    37 class SubTasksDone;

    37 class WorkGang;

    38 class WorkGang;

    38 

    39 

    78   SoftRefGenPolicy _soft_ref_gen_policy;

    79   SoftRefGenPolicy _soft_ref_gen_policy;

    79 

    80 

    80   // The sizing of the heap is controlled by a sizing policy.

    81   // The sizing of the heap is controlled by a sizing policy.

    81   AdaptiveSizePolicy* _size_policy;

    82   AdaptiveSizePolicy* _size_policy;

    82 

    83 

    83   // Indicates that the most recent previous incremental collection failed.

    86   // Indicates that the most recent previous incremental collection failed.

    84   // The flag is cleared when an action is taken that might clear the

    87   // The flag is cleared when an action is taken that might clear the

    85   // condition that caused that incremental collection to fail.

    88   // condition that caused that incremental collection to fail.

    86   bool _incremental_collection_failed;

    89   bool _incremental_collection_failed;

    87 

    90 

   153   // we absolutely __must__ clear soft refs?

   156   // we absolutely __must__ clear soft refs?

   154   bool must_clear_all_soft_refs();

   157   bool must_clear_all_soft_refs();

   155 

   158 

   156   GenCollectedHeap(GenCollectorPolicy *policy,

   159   GenCollectedHeap(GenCollectorPolicy *policy,

   157                    Generation::Name young,

   160                    Generation::Name young,

   159 

   163 

   160   virtual void check_gen_kinds() = 0;

   164   virtual void check_gen_kinds() = 0;

   161 

   165 

   162 public:

   166 public:

   163 

   167 

   189 

   193 

   190   // Adaptive size policy

   194   // Adaptive size policy

   191   virtual AdaptiveSizePolicy* size_policy() {

   195   virtual AdaptiveSizePolicy* size_policy() {

   192     return _size_policy;

   196     return _size_policy;

   193   }

   197   }

   194 

   201 

   195   // Return the (conservative) maximum heap alignment

   202   // Return the (conservative) maximum heap alignment

   196   static size_t conservative_max_heap_alignment() {

   203   static size_t conservative_max_heap_alignment() {

   197     return Generation::GenGrain;

   204     return Generation::GenGrain;

   198   }

   205   }