src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp

Print this page




  89 
  90   void post_resize();
  91 
  92  public:
  93   // Initialize the generation.
  94   PSOldGen(ReservedSpace rs, size_t alignment,
  95            size_t initial_size, size_t min_size, size_t max_size,
  96            const char* perf_data_name, int level);
  97 
  98   PSOldGen(size_t initial_size, size_t min_size, size_t max_size,
  99            const char* perf_data_name, int level);
 100 
 101   void initialize(ReservedSpace rs, size_t alignment,
 102                   const char* perf_data_name, int level);
 103   void initialize_virtual_space(ReservedSpace rs, size_t alignment);
 104   void initialize_work(const char* perf_data_name, int level);
 105 
 106   MemRegion reserved() const                { return _reserved; }
 107   virtual size_t max_gen_size()             { return _max_gen_size; }
 108   size_t min_gen_size()                     { return _min_gen_size; }

 109 
 110   // Returns limit on the maximum size of the generation.  This
 111   // is the same as _max_gen_size for PSOldGen but need not be
 112   // for a derived class.
 113   virtual size_t gen_size_limit();
 114 
 115   bool is_in(const void* p) const           {
 116     return _virtual_space->contains((void *)p);
 117   }
 118 
 119   bool is_in_reserved(const void* p) const {
 120     return reserved().contains(p);
 121   }
 122 
 123   MutableSpace*         object_space() const      { return _object_space; }
 124   PSMarkSweepDecorator* object_mark_sweep() const { return _object_mark_sweep; }
 125   ObjectStartArray*     start_array()             { return &_start_array; }
 126   PSVirtualSpace*       virtual_space() const     { return _virtual_space;}
 127 
 128   // Has the generation been successfully allocated?


 172   void verify_object_start_array();
 173 
 174   // These should not used
 175   virtual void reset_after_change();
 176 
 177   // These should not used
 178   virtual size_t available_for_expansion();
 179   virtual size_t available_for_contraction();
 180 
 181   void space_invariants() PRODUCT_RETURN;
 182 
 183   // Performace Counter support
 184   void update_counters();
 185 
 186   // Printing support
 187   virtual const char* name() const { return _name; }
 188 
 189   // Debugging support
 190   // Save the tops of all spaces for later use during mangling.
 191   void record_spaces_top() PRODUCT_RETURN;


 192 };


  89 
  90   void post_resize();
  91 
  92  public:
  93   // Initialize the generation.
  94   PSOldGen(ReservedSpace rs, size_t alignment,
  95            size_t initial_size, size_t min_size, size_t max_size,
  96            const char* perf_data_name, int level);
  97 
  98   PSOldGen(size_t initial_size, size_t min_size, size_t max_size,
  99            const char* perf_data_name, int level);
 100 
 101   void initialize(ReservedSpace rs, size_t alignment,
 102                   const char* perf_data_name, int level);
 103   void initialize_virtual_space(ReservedSpace rs, size_t alignment);
 104   void initialize_work(const char* perf_data_name, int level);
 105 
 106   MemRegion reserved() const                { return _reserved; }
 107   virtual size_t max_gen_size()             { return _max_gen_size; }
 108   size_t min_gen_size()                     { return _min_gen_size; }
 109   size_t init_gen_size()                    { return _init_gen_size; }
 110 
 111   // Returns limit on the maximum size of the generation.  This
 112   // is the same as _max_gen_size for PSOldGen but need not be
 113   // for a derived class.
 114   virtual size_t gen_size_limit();
 115 
 116   bool is_in(const void* p) const           {
 117     return _virtual_space->contains((void *)p);
 118   }
 119 
 120   bool is_in_reserved(const void* p) const {
 121     return reserved().contains(p);
 122   }
 123 
 124   MutableSpace*         object_space() const      { return _object_space; }
 125   PSMarkSweepDecorator* object_mark_sweep() const { return _object_mark_sweep; }
 126   ObjectStartArray*     start_array()             { return &_start_array; }
 127   PSVirtualSpace*       virtual_space() const     { return _virtual_space;}
 128 
 129   // Has the generation been successfully allocated?


 173   void verify_object_start_array();
 174 
 175   // These should not used
 176   virtual void reset_after_change();
 177 
 178   // These should not used
 179   virtual size_t available_for_expansion();
 180   virtual size_t available_for_contraction();
 181 
 182   void space_invariants() PRODUCT_RETURN;
 183 
 184   // Performace Counter support
 185   void update_counters();
 186 
 187   // Printing support
 188   virtual const char* name() const { return _name; }
 189 
 190   // Debugging support
 191   // Save the tops of all spaces for later use during mangling.
 192   void record_spaces_top() PRODUCT_RETURN;
 193 
 194   void try_to_shrink_by(size_t shrink_bytes);
 195 };