*** old/src/share/vm/memory/generation.cpp	Fri Oct 17 16:10:05 2014
--- new/src/share/vm/memory/generation.cpp	Fri Oct 17 16:10:05 2014

*** 43,54 ****
--- 43,53 ----
  #include "utilities/copy.hpp"
  #include "utilities/events.hpp"
  
  PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  
- Generation::Generation(ReservedSpace rs, size_t initial_size, int level) :
    _level(level),
    _ref_processor(NULL) {
    if (!_virtual_space.initialize(rs, initial_size)) {
      vm_exit_during_initialization("Could not reserve enough space for "
                      "object heap");
    }

*** 61,73 ****
--- 60,74 ----
    _reserved = MemRegion((HeapWord*)_virtual_space.low_boundary(),
            (HeapWord*)_virtual_space.high_boundary());
  }
  
  GenerationSpec* Generation::spec() {
!   GenCollectorPolicy* gcp = GenCollectedHeap::heap()->gen_policy();
    assert(0 <= level() && level() < gcp->number_of_generations(), "Bad gen level");
!   return level() == 0 ? gcp->young_gen_spec() : gcp->old_gen_spec();
!   GenCollectedHeap* gch = GenCollectedHeap::heap();
+   if (this == gch->young_gen()) {
!     return gch->gen_policy()->young_gen_spec();
+   }
+   return gch->gen_policy()->old_gen_spec();
  }
  
  size_t Generation::max_capacity() const {
    return reserved().byte_size();
  }

*** 112,124 ****
--- 113,133 ----
  void Generation::print_summary_info() { print_summary_info_on(tty); }
  
  void Generation::print_summary_info_on(outputStream* st) {
    StatRecord* sr = stat_record();
    double time = sr->accumulated_time.seconds();
+   // I didn't want to change the logging when removing the level concept,
+   // but I guess this logging could say young/old or something instead of 0/1.
+   int level;
+   if (this == GenCollectedHeap::heap()->young_gen()) {
+     level = 0;
+   } else {
+     level = 1;
+   }
    st->print_cr("[Accumulated GC generation %d time %3.7f secs, "
                 "%d GC's, avg GC time %3.7f]",
-                level(), time, sr->invocations,
                 sr->invocations > 0 ? time / sr->invocations : 0.0);
  }
  
  // Utility iterator classes
  

*** 157,185 ****
--- 166,183 ----
           (kind() == Generation::ParNew),
      "Wrong youngest generation type");
    return (DefNewGeneration*) this;
  }
  
  Generation* Generation::next_gen() const {
    GenCollectedHeap* gch = GenCollectedHeap::heap();
    if (level() == 0) {
      return gch->old_gen();
    } else {
      return NULL;
    }
  }
  
  size_t Generation::max_contiguous_available() const {
    // The largest number of contiguous free words in this or any higher generation.
!   size_t max = 0;
    for (const Generation* gen = this; gen != NULL; gen = gen->next_gen()) {
      size_t avail = gen->contiguous_available();
      if (avail > max) {
        max = avail;
      }
!   size_t avail = contiguous_available();
+   size_t old_avail = 0;
+   if (this == GenCollectedHeap::heap()->young_gen()) {
+     old_avail = GenCollectedHeap::heap()->old_gen()->contiguous_available();
    }
!   return max;
!   return MAX2(avail, old_avail);
  }
  
  bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
    size_t available = max_contiguous_available();
    bool   res = (available >= max_promotion_in_bytes);

*** 374,386 ****
--- 372,383 ----
      sp = sp->next_compaction_space();
    }
  }
  
  CardGeneration::CardGeneration(ReservedSpace rs, size_t initial_byte_size,
                                 int level,
                                 GenRemSet* remset) :
-   Generation(rs, initial_byte_size, level), _rs(remset),
    _shrink_factor(0), _min_heap_delta_bytes(), _capacity_at_prologue(),
    _used_at_prologue()
  {
    HeapWord* start = (HeapWord*)rs.base();
    size_t reserved_byte_size = rs.size();

*** 632,642 ****
--- 629,639 ----
    gc_timer->register_gc_start();
  
    SerialOldTracer* gc_tracer = GenMarkSweep::gc_tracer();
    gc_tracer->report_gc_start(gch->gc_cause(), gc_timer->gc_start());
  
-   GenMarkSweep::invoke_at_safepoint(_level, ref_processor(), clear_all_soft_refs);
  
    gc_timer->register_gc_end();
  
    gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions());