1 /*
   2  * Copyright 2001-2008 Sun Microsystems, Inc.  All Rights Reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  20  * CA 95054 USA or visit www.sun.com if you need additional information or
  21  * have any questions.
  22  *
  23  */
  24 
  25 class PSMarkSweepDecorator;
  26 
  27 class PSYoungGen : public CHeapObj {
  28   friend class VMStructs;
  29   friend class ParallelScavengeHeap;
  30   friend class AdjoiningGenerations;
  31 
  32  protected:
  33   MemRegion       _reserved;
  34   PSVirtualSpace* _virtual_space;
  35 
  36   // Spaces
  37   MutableSpace* _eden_space;
  38   MutableSpace* _from_space;
  39   MutableSpace* _to_space;
  40 
  41 
  42   // MarkSweep Decorators
  43   PSMarkSweepDecorator* _eden_mark_sweep;
  44   PSMarkSweepDecorator* _from_mark_sweep;
  45   PSMarkSweepDecorator* _to_mark_sweep;
  46 
  47   // Sizing information, in bytes, set in constructor
  48   const size_t _init_gen_size;
  49   const size_t _min_gen_size;
  50   const size_t _max_gen_size;
  51 
  52   // Performance counters
  53   PSGenerationCounters*     _gen_counters;
  54   SpaceCounters*            _eden_counters;
  55   SpaceCounters*            _from_counters;
  56   SpaceCounters*            _to_counters;
  57 
  58   // Initialize the space boundaries
  59   void compute_initial_space_boundaries();
  60 
  61   // Space boundary helper
  62   void set_space_boundaries(size_t eden_size, size_t survivor_size);
  63 
  64   virtual bool resize_generation(size_t eden_size, size_t survivor_size);
  65   virtual void resize_spaces(size_t eden_size, size_t survivor_size);
  66 
  67   // Adjust the spaces to be consistent with the virtual space.
  68   void post_resize();
  69 
  70   // Return number of bytes that the generation can change.
  71   // These should not be used by PSYoungGen
  72   virtual size_t available_for_expansion();
  73   virtual size_t available_for_contraction();
  74 
  75   // Given a desired shrinkage in the size of the young generation,
  76   // return the actual size available for shrinkage.
  77   virtual size_t limit_gen_shrink(size_t desired_change);
  78   // returns the number of bytes available from the current size
  79   // down to the minimum generation size.
  80   size_t available_to_min_gen();
  81   // Return the number of bytes available for shrinkage considering
  82   // the location the live data in the generation.
  83   virtual size_t available_to_live();
  84 
  85  public:
  86   // Initialize the generation.
  87   PSYoungGen(size_t        initial_byte_size,
  88              size_t        minimum_byte_size,
  89              size_t        maximum_byte_size);
  90   void initialize_work();
  91   virtual void initialize(ReservedSpace rs, size_t alignment);
  92   virtual void initialize_virtual_space(ReservedSpace rs, size_t alignment);
  93 
  94   MemRegion reserved() const            { return _reserved; }
  95 
  96   bool is_in(const void* p) const   {
  97       return _virtual_space->contains((void *)p);
  98   }
  99 
 100   bool is_in_reserved(const void* p) const   {
 101       return reserved().contains((void *)p);
 102   }
 103 
 104   MutableSpace*   eden_space() const    { return _eden_space; }
 105   MutableSpace*   from_space() const    { return _from_space; }
 106   MutableSpace*   to_space() const      { return _to_space; }
 107   PSVirtualSpace* virtual_space() const { return _virtual_space; }
 108 
 109   // For Adaptive size policy
 110   size_t min_gen_size() { return _min_gen_size; }
 111 
 112   // MarkSweep support
 113   PSMarkSweepDecorator* eden_mark_sweep() const    { return _eden_mark_sweep; }
 114   PSMarkSweepDecorator* from_mark_sweep() const    { return _from_mark_sweep; }
 115   PSMarkSweepDecorator* to_mark_sweep() const      { return _to_mark_sweep;   }
 116 
 117   void precompact();
 118   void adjust_pointers();
 119   void compact();
 120 
 121   // Parallel Old
 122   void move_and_update(ParCompactionManager* cm);
 123 
 124   // Called during/after gc
 125   void swap_spaces();
 126 
 127   // Resize generation using suggested free space size and survivor size
 128   // NOTE:  "eden_size" and "survivor_size" are suggestions only. Current
 129   //        heap layout (particularly, live objects in from space) might
 130   //        not allow us to use these values.
 131   void resize(size_t eden_size, size_t survivor_size);
 132 
 133   // Size info
 134   size_t capacity_in_bytes() const;
 135   size_t used_in_bytes() const;
 136   size_t free_in_bytes() const;
 137 
 138   size_t capacity_in_words() const;
 139   size_t used_in_words() const;
 140   size_t free_in_words() const;
 141 
 142   // The max this generation can grow to
 143   size_t max_size() const            { return _reserved.byte_size(); }
 144 
 145   // The max this generation can grow to if the boundary between
 146   // the generations are allowed to move.
 147   size_t gen_size_limit() const { return _max_gen_size; }
 148 
 149   bool is_maximal_no_gc() const {
 150     return true;  // never expands except at a GC
 151   }
 152 
 153   // Allocation
 154   HeapWord* allocate(size_t word_size, bool is_tlab) {
 155     HeapWord* result = eden_space()->cas_allocate(word_size);
 156     return result;
 157   }
 158 
 159   HeapWord** top_addr() const   { return eden_space()->top_addr(); }
 160   HeapWord** end_addr() const   { return eden_space()->end_addr(); }
 161 
 162   // Iteration.
 163   void oop_iterate(OopClosure* cl);
 164   void object_iterate(ObjectClosure* cl);
 165 
 166   virtual void reset_after_change();
 167   virtual void reset_survivors_after_shrink();
 168 
 169   // Performance Counter support
 170   void update_counters();
 171 
 172   // Debugging - do not use for time critical operations
 173   void print() const;
 174   void print_on(outputStream* st) const;
 175   void print_used_change(size_t prev_used) const;
 176   virtual const char* name() const { return "PSYoungGen"; }
 177 
 178   void verify(bool allow_dirty);
 179 
 180   // Space boundary invariant checker
 181   void space_invariants() PRODUCT_RETURN;
 182 
 183   // Helper for mangling survivor spaces.
 184   void mangle_survivors(MutableSpace* s1,
 185                         MemRegion s1MR,
 186                         MutableSpace* s2,
 187                         MemRegion s2MR) PRODUCT_RETURN;
 188 
 189   void record_spaces_top() PRODUCT_RETURN;
 190 };