1 /*
   2  * Copyright (c) 2001, 2012, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_MEMORY_DEFNEWGENERATION_HPP
  26 #define SHARE_VM_MEMORY_DEFNEWGENERATION_HPP
  27 
  28 #include "gc_implementation/shared/ageTable.hpp"
  29 #include "gc_implementation/shared/cSpaceCounters.hpp"
  30 #include "gc_implementation/shared/generationCounters.hpp"
  31 #include "memory/generation.inline.hpp"
  32 #include "utilities/stack.hpp"
  33 
  34 class EdenSpace;
  35 class ContiguousSpace;
  36 class ScanClosure;
  37 
  38 // DefNewGeneration is a young generation containing eden, from- and
  39 // to-space.
  40 
  41 class DefNewGeneration: public Generation {
  42   friend class VMStructs;
  43 
  44 protected:
  45   Generation* _next_gen;
  46   uint        _tenuring_threshold;   // Tenuring threshold for next collection.
  47   ageTable    _age_table;
  48   // Size of object to pretenure in words; command line provides bytes
  49   size_t        _pretenure_size_threshold_words;
  50 
  51   ageTable*   age_table() { return &_age_table; }
  52   // Initialize state to optimistically assume no promotion failure will
  53   // happen.
  54   void   init_assuming_no_promotion_failure();
  55   // True iff a promotion has failed in the current collection.
  56   bool   _promotion_failed;
  57   bool   promotion_failed() { return _promotion_failed; }
  58 
  59   // Handling promotion failure.  A young generation collection
  60   // can fail if a live object cannot be copied out of its
  61   // location in eden or from-space during the collection.  If
  62   // a collection fails, the young generation is left in a
  63   // consistent state such that it can be collected by a
  64   // full collection.
  65   //   Before the collection
  66   //     Objects are in eden or from-space
  67   //     All roots into the young generation point into eden or from-space.
  68   //
  69   //   After a failed collection
  70   //     Objects may be in eden, from-space, or to-space
  71   //     An object A in eden or from-space may have a copy B
  72   //       in to-space.  If B exists, all roots that once pointed
  73   //       to A must now point to B.
  74   //     All objects in the young generation are unmarked.
  75   //     Eden, from-space, and to-space will all be collected by
  76   //       the full collection.
  77   void handle_promotion_failure(oop);
  78 
  79   // In the absence of promotion failure, we wouldn't look at "from-space"
  80   // objects after a young-gen collection.  When promotion fails, however,
  81   // the subsequent full collection will look at from-space objects:
  82   // therefore we must remove their forwarding pointers.
  83   void remove_forwarding_pointers();
  84 
  85   // Preserve the mark of "obj", if necessary, in preparation for its mark
  86   // word being overwritten with a self-forwarding-pointer.
  87   void   preserve_mark_if_necessary(oop obj, markOop m);
  88   void   preserve_mark(oop obj, markOop m);    // work routine used by the above
  89 
  90   // Together, these keep <object with a preserved mark, mark value> pairs.
  91   // They should always contain the same number of elements.
  92   Stack<oop, mtGC>     _objs_with_preserved_marks;
  93   Stack<markOop, mtGC> _preserved_marks_of_objs;
  94 
  95   // Promotion failure handling
  96   ExtendedOopClosure *_promo_failure_scan_stack_closure;
  97   void set_promo_failure_scan_stack_closure(ExtendedOopClosure *scan_stack_closure) {
  98     _promo_failure_scan_stack_closure = scan_stack_closure;
  99   }
 100 
 101   Stack<oop, mtGC> _promo_failure_scan_stack;
 102   void drain_promo_failure_scan_stack(void);
 103   bool _promo_failure_drain_in_progress;
 104 
 105   // Performance Counters
 106   GenerationCounters*  _gen_counters;
 107   CSpaceCounters*      _eden_counters;
 108   CSpaceCounters*      _from_counters;
 109   CSpaceCounters*      _to_counters;
 110 
 111   // sizing information
 112   size_t               _max_eden_size;
 113   size_t               _max_survivor_size;
 114 
 115   // Allocation support
 116   bool _should_allocate_from_space;
 117   bool should_allocate_from_space() const {
 118     return _should_allocate_from_space;
 119   }
 120   void clear_should_allocate_from_space() {
 121     _should_allocate_from_space = false;
 122   }
 123   void set_should_allocate_from_space() {
 124     _should_allocate_from_space = true;
 125   }
 126 
 127   // Tenuring
 128   void adjust_desired_tenuring_threshold();
 129 
 130   // Spaces
 131   EdenSpace*       _eden_space;
 132   ContiguousSpace* _from_space;
 133   ContiguousSpace* _to_space;
 134 
 135   enum SomeProtectedConstants {
 136     // Generations are GenGrain-aligned and have size that are multiples of
 137     // GenGrain.
 138     MinFreeScratchWords = 100
 139   };
 140 
 141   // Return the size of a survivor space if this generation were of size
 142   // gen_size.
 143   size_t compute_survivor_size(size_t gen_size, size_t alignment) const {
 144     size_t n = gen_size / (SurvivorRatio + 2);
 145     return n > alignment ? align_size_down(n, alignment) : alignment;
 146   }
 147 
 148  public:  // was "protected" but caused compile error on win32
 149   class IsAliveClosure: public BoolObjectClosure {
 150     Generation* _g;
 151   public:
 152     IsAliveClosure(Generation* g);
 153     void do_object(oop p);
 154     bool do_object_b(oop p);
 155   };
 156 
 157   class KeepAliveClosure: public OopClosure {
 158   protected:
 159     ScanWeakRefClosure* _cl;
 160     CardTableRS* _rs;
 161     template <class T> void do_oop_work(T* p);
 162   public:
 163     KeepAliveClosure(ScanWeakRefClosure* cl);
 164     virtual void do_oop(oop* p);
 165     virtual void do_oop(narrowOop* p);
 166   };
 167 
 168   class FastKeepAliveClosure: public KeepAliveClosure {
 169   protected:
 170     HeapWord* _boundary;
 171     template <class T> void do_oop_work(T* p);
 172   public:
 173     FastKeepAliveClosure(DefNewGeneration* g, ScanWeakRefClosure* cl);
 174     virtual void do_oop(oop* p);
 175     virtual void do_oop(narrowOop* p);
 176   };
 177 
 178   class EvacuateFollowersClosure: public VoidClosure {
 179     GenCollectedHeap* _gch;
 180     int _level;
 181     ScanClosure* _scan_cur_or_nonheap;
 182     ScanClosure* _scan_older;
 183   public:
 184     EvacuateFollowersClosure(GenCollectedHeap* gch, int level,
 185                              ScanClosure* cur, ScanClosure* older);
 186     void do_void();
 187   };
 188 
 189   class FastEvacuateFollowersClosure: public VoidClosure {
 190     GenCollectedHeap* _gch;
 191     int _level;
 192     DefNewGeneration* _gen;
 193     FastScanClosure* _scan_cur_or_nonheap;
 194     FastScanClosure* _scan_older;
 195   public:
 196     FastEvacuateFollowersClosure(GenCollectedHeap* gch, int level,
 197                                  DefNewGeneration* gen,
 198                                  FastScanClosure* cur,
 199                                  FastScanClosure* older);
 200     void do_void();
 201   };
 202 
 203  public:
 204   DefNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level,
 205                    const char* policy="Copy");
 206 
 207   virtual Generation::Name kind() { return Generation::DefNew; }
 208 
 209   // Accessing spaces
 210   EdenSpace*       eden() const           { return _eden_space; }
 211   ContiguousSpace* from() const           { return _from_space;  }
 212   ContiguousSpace* to()   const           { return _to_space;    }
 213 
 214   virtual CompactibleSpace* first_compaction_space() const;
 215 
 216   // Space enquiries
 217   size_t capacity() const;
 218   size_t used() const;
 219   size_t free() const;
 220   size_t max_capacity() const;
 221   size_t capacity_before_gc() const;
 222   size_t unsafe_max_alloc_nogc() const;
 223   size_t contiguous_available() const;
 224 
 225   size_t max_eden_size() const              { return _max_eden_size; }
 226   size_t max_survivor_size() const          { return _max_survivor_size; }
 227 
 228   bool supports_inline_contig_alloc() const { return true; }
 229   HeapWord** top_addr() const;
 230   HeapWord** end_addr() const;
 231 
 232   // Thread-local allocation buffers
 233   bool supports_tlab_allocation() const { return true; }
 234   size_t tlab_capacity() const;
 235   size_t unsafe_max_tlab_alloc() const;
 236 
 237   // Grow the generation by the specified number of bytes.
 238   // The size of bytes is assumed to be properly aligned.
 239   // Return true if the expansion was successful.
 240   bool expand(size_t bytes);
 241 
 242   // DefNewGeneration cannot currently expand except at
 243   // a GC.
 244   virtual bool is_maximal_no_gc() const { return true; }
 245 
 246   // Iteration
 247   void object_iterate(ObjectClosure* blk);
 248   void object_iterate_since_last_GC(ObjectClosure* cl);
 249 
 250   void younger_refs_iterate(OopsInGenClosure* cl);
 251 
 252   void space_iterate(SpaceClosure* blk, bool usedOnly = false);
 253 
 254   // Allocation support
 255   virtual bool should_allocate(size_t word_size, bool is_tlab) {
 256     assert(UseTLAB || !is_tlab, "Should not allocate tlab");
 257 
 258     size_t overflow_limit    = (size_t)1 << (BitsPerSize_t - LogHeapWordSize);
 259 
 260     const bool non_zero      = word_size > 0;
 261     const bool overflows     = word_size >= overflow_limit;
 262     const bool check_too_big = _pretenure_size_threshold_words > 0;
 263     const bool not_too_big   = word_size < _pretenure_size_threshold_words;
 264     const bool size_ok       = is_tlab || !check_too_big || not_too_big;
 265 
 266     bool result = !overflows &&
 267                   non_zero   &&
 268                   size_ok;
 269 
 270     return result;
 271   }
 272 
 273   HeapWord* allocate(size_t word_size, bool is_tlab);
 274   HeapWord* allocate_from_space(size_t word_size);
 275 
 276   HeapWord* par_allocate(size_t word_size, bool is_tlab);
 277 
 278   // Prologue & Epilogue
 279   virtual void gc_prologue(bool full);
 280   virtual void gc_epilogue(bool full);
 281 
 282   // Save the tops for eden, from, and to
 283   virtual void record_spaces_top();
 284 
 285   // Doesn't require additional work during GC prologue and epilogue
 286   virtual bool performs_in_place_marking() const { return false; }
 287 
 288   // Accessing marks
 289   void save_marks();
 290   void reset_saved_marks();
 291   bool no_allocs_since_save_marks();
 292 
 293   // Need to declare the full complement of closures, whether we'll
 294   // override them or not, or get message from the compiler:
 295   //   oop_since_save_marks_iterate_nv hides virtual function...
 296 #define DefNew_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \
 297   void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl);
 298 
 299   ALL_SINCE_SAVE_MARKS_CLOSURES(DefNew_SINCE_SAVE_MARKS_DECL)
 300 
 301 #undef DefNew_SINCE_SAVE_MARKS_DECL
 302 
 303   // For non-youngest collection, the DefNewGeneration can contribute
 304   // "to-space".
 305   virtual void contribute_scratch(ScratchBlock*& list, Generation* requestor,
 306                           size_t max_alloc_words);
 307 
 308   // Reset for contribution of "to-space".
 309   virtual void reset_scratch();
 310 
 311   // GC support
 312   virtual void compute_new_size();
 313 
 314   // Returns true if the collection is likely to be safely
 315   // completed. Even if this method returns true, a collection
 316   // may not be guaranteed to succeed, and the system should be
 317   // able to safely unwind and recover from that failure, albeit
 318   // at some additional cost. Override superclass's implementation.
 319   virtual bool collection_attempt_is_safe();
 320 
 321   virtual void collect(bool   full,
 322                        bool   clear_all_soft_refs,
 323                        size_t size,
 324                        bool   is_tlab);
 325   HeapWord* expand_and_allocate(size_t size,
 326                                 bool is_tlab,
 327                                 bool parallel = false);
 328 
 329   oop copy_to_survivor_space(oop old);
 330   uint tenuring_threshold() { return _tenuring_threshold; }
 331 
 332   // Performance Counter support
 333   void update_counters();
 334 
 335   // Printing
 336   virtual const char* name() const;
 337   virtual const char* short_name() const { return "DefNew"; }
 338 
 339   bool must_be_youngest() const { return true; }
 340   bool must_be_oldest() const { return false; }
 341 
 342   // PrintHeapAtGC support.
 343   void print_on(outputStream* st) const;
 344 
 345   void verify();
 346 
 347   bool promo_failure_scan_is_complete() const {
 348     return _promo_failure_scan_stack.is_empty();
 349   }
 350 
 351  protected:
 352   // If clear_space is true, clear the survivor spaces.  Eden is
 353   // cleared if the minimum size of eden is 0.  If mangle_space
 354   // is true, also mangle the space in debug mode.
 355   void compute_space_boundaries(uintx minimum_eden_size,
 356                                 bool clear_space,
 357                                 bool mangle_space);
 358   // Scavenge support
 359   void swap_spaces();
 360 };
 361 
 362 #endif // SHARE_VM_MEMORY_DEFNEWGENERATION_HPP