src/share/vm/memory/tenuredGeneration.hpp

rev 7420 : [mq]: removeOneContigSpaceGeneration

*** 29,49 ****
  #include "gc_implementation/shared/gcStats.hpp"
  #include "gc_implementation/shared/generationCounters.hpp"
  #include "memory/generation.hpp"
  #include "utilities/macros.hpp"
  
! // TenuredGeneration models the heap containing old (promoted/tenured) objects.
  
! class TenuredGeneration: public OneContigSpaceCardGeneration {
    friend class VMStructs;
   protected:
    GenerationCounters*   _gen_counters;
    CSpaceCounters*       _space_counters;
  
   public:
!   TenuredGeneration(ReservedSpace rs, size_t initial_byte_size, int level,
!                     GenRemSet* remset);
  
    Generation::Name kind() { return Generation::MarkSweepCompact; }
  
    // Printing
    const char* name() const { return "tenured generation"; }
--- 29,73 ----
  #include "gc_implementation/shared/gcStats.hpp"
  #include "gc_implementation/shared/generationCounters.hpp"
  #include "memory/generation.hpp"
  #include "utilities/macros.hpp"
  
! // TenuredGeneration models the heap containing old (promoted/tenured) objects
! // contained in a single contiguous space.
! //
! // Garbage collection is performed using mark-compact.
  
! class TenuredGeneration: public CardGeneration {
    friend class VMStructs;
+   // Abstractly, this is a subtype that gets access to protected fields.
+   friend class VM_PopulateDumpSharedSpace;
+ 
   protected:
+   ContiguousSpace*  _the_space;       // actual space holding objects
+   WaterMark  _last_gc;                // watermark between objects allocated before
+                                       // and after last GC.
+ 
    GenerationCounters*   _gen_counters;
    CSpaceCounters*       _space_counters;
  
+   // Grow generation with specified size (returns false if unable to grow)
+   virtual bool grow_by(size_t bytes);
+   // Grow generation to reserved size.
+   virtual bool grow_to_reserved();
+   // Shrink generation with specified size (returns false if unable to shrink)
+   void shrink_by(size_t bytes);
+ 
+   // Allocation failure
+   virtual bool expand(size_t bytes, size_t expand_bytes);
+   void shrink(size_t bytes);
+ 
+   // Accessing spaces
+   ContiguousSpace* the_space() const { return _the_space; }
+ 
   public:
!   TenuredGeneration(ReservedSpace rs, size_t initial_byte_size,
!                                int level, GenRemSet* remset);
  
    Generation::Name kind() { return Generation::MarkSweepCompact; }
  
    // Printing
    const char* name() const { return "tenured generation"; }
*** 55,77 ****
--- 79,158 ----
    // set.
    virtual bool full_collects_younger_generations() const {
      return !ScavengeBeforeFullGC;
    }
  
+   inline bool is_in(const void* p) const;
+ 
+   // Space enquiries
+   size_t capacity() const;
+   size_t used() const;
+   size_t free() const;
+ 
+   MemRegion used_region() const;
+ 
+   size_t unsafe_max_alloc_nogc() const;
+   size_t contiguous_available() const;
+ 
+   // Iteration
+   void object_iterate(ObjectClosure* blk);
+   void space_iterate(SpaceClosure* blk, bool usedOnly = false);
+ 
+   void younger_refs_iterate(OopsInGenClosure* blk);
+ 
+   inline CompactibleSpace* first_compaction_space() const;
+ 
+   virtual inline HeapWord* allocate(size_t word_size, bool is_tlab);
+   virtual inline HeapWord* par_allocate(size_t word_size, bool is_tlab);
+ 
+   // Accessing marks
+   inline WaterMark top_mark();
+   inline WaterMark bottom_mark();
+ 
+ #define TenuredGen_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix)     \
+   void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl);
+   TenuredGen_SINCE_SAVE_MARKS_DECL(OopsInGenClosure,_v)
+   SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(TenuredGen_SINCE_SAVE_MARKS_DECL)
+ 
+   void save_marks();
+   void reset_saved_marks();
+   bool no_allocs_since_save_marks();
+ 
+   inline size_t block_size(const HeapWord* addr) const;
+ 
+   inline bool block_is_obj(const HeapWord* addr) const;
+ 
+   virtual void collect(bool full,
+                        bool clear_all_soft_refs,
+                        size_t size,
+                        bool is_tlab);
+   HeapWord* expand_and_allocate(size_t size,
+                                 bool is_tlab,
+                                 bool parallel = false);
+ 
+   virtual void prepare_for_verify();
+ 
+ 
    virtual void gc_prologue(bool full);
+   virtual void gc_epilogue(bool full);
    bool should_collect(bool   full,
                        size_t word_size,
                        bool   is_tlab);
  
    virtual void compute_new_size();
  
    // Performance Counter support
    void update_counters();
  
+   virtual void record_spaces_top();
+ 
    // Statistics
  
    virtual void update_gc_stats(int level, bool full);
  
    virtual bool promotion_attempt_is_safe(size_t max_promoted_in_bytes) const;
+ 
+   virtual void verify();
+   virtual void print_on(outputStream* st) const;
  };
  
  #endif // SHARE_VM_MEMORY_TENUREDGENERATION_HPP