*** old/src/share/vm/memory/generation.hpp	Fri Oct 17 16:28:46 2014
--- new/src/share/vm/memory/generation.hpp	Fri Oct 17 16:28:46 2014

*** 82,92 ****
--- 82,91 ----
    size_t num_words;
    HeapWord scratch_space[1];  // Actually, of size "num_words-2" (assuming
                                // first two fields are word-sized.)
  };
  
  
  class Generation: public CHeapObj<mtGC> {
    friend class VMStructs;
   private:
    jlong _time_of_last_gc; // time when last gc on this generation happened (ms)
    MemRegion _prev_used_region; // for collectors that want to "remember" a value for

*** 100,127 ****
--- 99,119 ----
    MemRegion _reserved;
  
    // Memory area reserved for generation
    VirtualSpace _virtual_space;
  
    // Level in the generation hierarchy.
    int _level;
  
    // ("Weak") Reference processing support
    ReferenceProcessor* _ref_processor;
  
    // Performance Counters
    CollectorCounters* _gc_counters;
  
    // Statistics for garbage collection
    GCStats* _gc_stats;
  
    // Returns the next generation in the configuration, or else NULL if this
    // is the highest generation.
    Generation* next_gen() const;
  
    // Initialize the generation.
-   Generation(ReservedSpace rs, size_t initial_byte_size, int level);
  
    // Apply "cl->do_oop" to (the address of) (exactly) all the ref fields in
    // "sp" that point into younger generations.
    // The iteration is only over objects allocated at the start of the
    // iterations; objects allocated as a result of applying the closure are

*** 136,145 ****
--- 128,142 ----
      MarkSweepCompact,
      ConcurrentMarkSweep,
      Other
    };
  
+   enum Type {
+     Young,
+     Old
+   };
+ 
    enum SomePublicConstants {
      // Generations are GenGrain-aligned and have size that are multiples of
      // GenGrain.
      // Note: on ARM we add 1 bit for card_table_base to be properly aligned
      // (we expect its low byte to be zero - see implementation of post_barrier)

*** 436,446 ****
--- 433,443 ----
    // occurred.  This allows the generation to decide what
    // statistics are valid to collect.  For example, the
    // generation can decide to gather the amount of promoted data
    // if the collection of the younger generations has completed.
    GCStats* gc_stats() const { return _gc_stats; }
!   virtual void update_gc_stats(int current_level, bool full) {}
!   virtual void update_gc_stats(Generation* current_generation, bool full) {}
  
    // Mark sweep support phase2
    virtual void prepare_for_compaction(CompactPoint* cp);
    // Mark sweep support phase3
    virtual void adjust_pointers();

*** 521,532 ****
--- 518,527 ----
  
    // Printing
    virtual const char* name() const = 0;
    virtual const char* short_name() const = 0;
  
    int level() const { return _level; }
  
    // Attributes
  
    // True iff the given generation may only be the youngest generation.
    virtual bool must_be_youngest() const = 0;
    // True iff the given generation may only be the oldest generation.

*** 636,647 ****
--- 631,641 ----
    // These are gathered in the gc_prologue (and should_collect)
    // to control growing/shrinking policy in spite of promotions.
    size_t _capacity_at_prologue;
    size_t _used_at_prologue;
  
!   CardGeneration(ReservedSpace rs, size_t initial_byte_size, int level,
                   GenRemSet* remset);
!   CardGeneration(ReservedSpace rs, size_t initial_byte_size, GenRemSet* remset);
  
   public:
  
    // Attempt to expand the generation by "bytes".  Expand by at a
    // minimum "expand_bytes".  Return true if some amount (not

*** 694,706 ****
--- 688,699 ----
    // Accessing spaces
    ContiguousSpace* the_space() const { return _the_space; }
  
   public:
    OneContigSpaceCardGeneration(ReservedSpace rs, size_t initial_byte_size,
                                 int level, GenRemSet* remset,
                                 ContiguousSpace* space) :
      CardGeneration(rs, initial_byte_size, level, remset),
+                                GenRemSet* remset, ContiguousSpace* space) :
+     CardGeneration(rs, initial_byte_size, remset),
      _the_space(space)
    {}
  
    inline bool is_in(const void* p) const;